/**
* Builds a directory of the object names.
*
* Allocate and initialize information for this instance of an RT
* model database.
*
* Returns -
* (struct rt_i *) Success
* RTI_NULL Fatal Error
*/
struct rt_i *
rt_dirbuild(const char *filename, char *buf, int len)
{
register struct rt_i *rtip;
register struct db_i *dbip; /* Database instance ptr */
if (rt_uniresource.re_magic == 0)
rt_init_resource(&rt_uniresource, 0, NULL);
if ((dbip = db_open(filename, DB_OPEN_READONLY)) == DBI_NULL)
return RTI_NULL; /* FAIL */
RT_CK_DBI(dbip);
if (db_dirbuild(dbip) < 0) {
db_close(dbip);
return RTI_NULL; /* FAIL */
}
rtip = rt_new_rti(dbip); /* clones dbip */
db_close(dbip); /* releases original dbip */
if (buf != (char *)NULL)
bu_strlcpy(buf, dbip->dbi_title, len);
return rtip; /* OK */
}
static int
list_geometry(ClientData UNUSED(clientData), Tcl_Interp *interp, int objc, Tcl_Obj *const *objv)
{
static struct db_i *dbip;
struct directory *dp;
int i;
struct bu_vls tclstr = BU_VLS_INIT_ZERO;
if (objc < 3) {
Tcl_WrongNumArgs(interp, 1, objv, "file varname");
return TCL_ERROR;
}
if ((dbip = db_open(Tcl_GetString(objv[1]), "r")) == DBI_NULL) {
bu_log("Unable to open geometry file (%s)\n", Tcl_GetString(objv[1]));
return TCL_ERROR;
}
db_dirbuild(dbip);
for (i = 0; i < RT_DBNHASH; i++) {
for (dp = dbip->dbi_Head[i]; dp != RT_DIR_NULL; dp = dp->d_forw) {
if (dp->d_flags & RT_DIR_HIDDEN) continue;
bu_vls_sprintf(&tclstr, "set %s [concat $%s [list %s]]", Tcl_GetString(objv[2]), Tcl_GetString(objv[2]), dp->d_namep);
Tcl_Eval(interp, bu_vls_addr(&tclstr));
}
}
db_close(dbip);
bu_vls_free(&tclstr);
return TCL_OK;
}
/**
* main driver logic that creates the various random metaballs and
* then creates another that combines them all into one.
*/
static void
make_spaghetti(const char *filename, const char *name, long count)
{
const char *balls[4] = {"someballs.s", "moreballs.s", "manyballs.s", NULL};
const char title[BUFSIZ] = "metaball";
struct rt_wdb *fp;
struct db_i *dbip;
long some, more, many;
/* get a write-only handle */
fp = wdb_fopen(filename);
if (fp == RT_WDB_NULL)
bu_exit(EXIT_FAILURE, "ERROR: unable to open file for writing.\n");
mk_id(fp, title);
/* just to make things interesting, make varying sized sets */
some = lrint(ceil((double)count * (1.0 / 111.0)));
more = lrint(ceil((double)count * (10.0 / 111.0)));
many = lrint(ceil((double)count * (100.0 / 111.0)));
/* create individual metaballs with random points using LIBWDB */
make_meatballs(fp, balls[0], some);
make_meatballs(fp, balls[1], more);
make_meatballs(fp, balls[2], many);
mk_comb1(fp, "someballs.r", balls[0], 1);
mk_comb1(fp, "moreballs.r", balls[1], 1);
mk_comb1(fp, "manyballs.r", balls[2], 1);
mk_comb1(fp, "meatballs.r", "meatballs.s", 1);
wdb_close(fp);
/* done with the write-only, now begins read/write */
dbip = db_open(filename, DB_OPEN_READWRITE);
if (dbip == DBI_NULL) {
perror("ERROR");
bu_exit(EXIT_FAILURE, "Failed to open geometry file [%s]. Aborting.\n", filename);
}
/* load a database directory */
db_dirbuild(dbip);
/* combine all metaballs into one "mega metaball" */
mix_balls(dbip, name, 3, balls);
/* and clean up */
db_close(dbip);
}
////////////////////////////////////////////////////////////////////////////////
// Read the BRL-CAD file
////////////////////////////////////////////////////////////////////////////////
BRLFile::BRLFile(char *filename, int v)
{
verbose=v;
dbip = db_open(filename, "r");
if(dbip==DBI_NULL)
return;
/* build a wdbp structure for convenient read/write */
wdbp = wdb_dbopen(dbip, RT_WDB_TYPE_DB_DISK);
if (db_dirbuild(dbip) < 0) { /* create directory database contents */
bu_log("Error building directory for %s\n", filename);
exit(-1);
}
}
bool
BRLCADWrapper::load(std::string &flnm)
{
/* open brlcad instance */
if ((dbip = db_open(flnm.c_str(), DB_OPEN_READONLY)) == DBI_NULL) {
bu_log("Cannot open input file (%s)\n", flnm.c_str());
return false;
}
if (db_dirbuild(dbip)) {
bu_log("ERROR: db_dirbuild failed: (%s)\n", flnm.c_str());
return false;
}
return true;
}
/**
* store an object as the "source" to compare with
*/
void
fit_store (char *obj, char *dbname, struct fitness_state *fstate)
{
struct db_i *db;
if ( (db=db_open(dbname, DB_OPEN_READONLY)) == DBI_NULL)
bu_exit(EXIT_FAILURE, "Failed to open geometry database file");
if (db_dirbuild(db) < 0)
bu_exit(EXIT_FAILURE, "Failed to build directory structure");
fstate->capture = 1;
fit_rt(obj, db, fstate);
db_close(db);
fstate->capture = 0;
}
int
main(int argc, char** argv)
{
struct rt_wdb* outfp;
ON_Brep* brep;
ON_TextLog error_log;
const char* id_name = "B-Rep Example";
const char* geom_name = "cube.s";
ON::Begin();
if (argc > 1) {
printf("Writing a twisted cube b-rep...\n");
outfp = wdb_fopen("brep_cube1.g");
mk_id(outfp, id_name);
brep = MakeTwistedCube(error_log);
mk_brep(outfp, geom_name, brep);
//mk_comb1(outfp, "cube.r", geom_name, 1);
unsigned char rgb[] = {255,255,255};
mk_region1(outfp, "cube.r", geom_name, "plastic", "", rgb);
wdb_close(outfp);
delete brep;
}
printf("Reading a twisted cube b-rep...\n");
struct db_i* dbip = db_open("brep_cube1.g", "r");
db_dirbuild(dbip);
struct directory* dirp;
if ((dirp = db_lookup(dbip, "cube.s", 0)) != DIR_NULL) {
printf("\tfound cube.s\n");
struct rt_db_internal ip;
mat_t mat;
MAT_IDN(mat);
if (rt_db_get_internal(&ip, dirp, dbip, mat, &rt_uniresource) >= 0) {
printPoints((struct rt_brep_internal*)ip.idb_ptr);
} else {
fprintf(stderr, "problem getting internal object rep\n");
}
}
db_close(dbip);
ON::End();
return 0;
}
struct db_i *
db_create(const char *name, int version)
{
FILE *fp;
struct db_i *dbip;
int result;
if (name == NULL) return DBI_NULL;
if (RT_G_DEBUG & DEBUG_DB)
bu_log("db_create(%s, %d)\n", name, version);
fp = fopen(name, "w+b");
if (fp == NULL) {
perror(name);
return DBI_NULL;
}
if (version == 5) {
result = db5_fwrite_ident(fp, DEFAULT_DB_TITLE, 1.0);
} else if (version == 4) {
result = db_fwrite_ident(fp, DEFAULT_DB_TITLE, 1.0);
} else {
bu_log("WARNING: db_create() was provided an unrecognized version number: %d\n", version);
result = db5_fwrite_ident(fp, DEFAULT_DB_TITLE, 1.0);
}
(void)fclose(fp);
if (result < 0)
return DBI_NULL;
if ((dbip = db_open(name, DB_OPEN_READWRITE)) == DBI_NULL)
return DBI_NULL;
/* Do a quick scan to determine version, find _GLOBAL, etc. */
if (db_dirbuild(dbip) < 0)
return DBI_NULL;
return dbip;
}
int
main(int argc, char **argv)
{
struct rt_wdb *fp;
struct db_i *dbip;
struct directory *dp;
long errors = 0;
struct bn_tol tol;
char name[17];
bu_setprogname(argv[0]);
/* FIXME: These need to be improved */
tol.magic = BN_TOL_MAGIC;
tol.dist = 0.0005;
tol.dist_sq = tol.dist * tol.dist;
tol.perp = 1e-6;
tol.para = 1 - tol.perp;
bu_debug = BU_DEBUG_COREDUMP;
rt_init_resource( &rt_uniresource, 0, NULL );
if ( argc != 3 ) {
fprintf(stderr, "Usage: %s v4.g v5.g\n", argv[0]);
return 1;
}
if ( (dbip = db_open(argv[1], DB_OPEN_READONLY)) == DBI_NULL ) {
perror( argv[1] );
return 2;
}
if ( (fp = wdb_fopen( argv[2] )) == NULL ) {
perror( argv[2] );
return 3;
}
if ( db_version(dbip) != 4 ) {
bu_log( "Input database must be a version 4 database!!!!\n" );
return 4;
}
RT_CK_DBI(dbip);
if ( db_dirbuild( dbip ) )
bu_exit(1, "db_dirbuild failed\n" );
db_update_ident( fp->dbip, dbip->dbi_title, dbip->dbi_local2base );
/* Retrieve every item in the input database */
FOR_ALL_DIRECTORY_START(dp, dbip) {
struct rt_db_internal intern;
int id;
int ret;
fprintf(stderr, "%.16s\n", dp->d_namep );
id = rt_db_get_internal( &intern, dp, dbip, NULL, &rt_uniresource );
if ( id < 0 ) {
fprintf(stderr,
"%s: rt_db_get_internal(%s) failure, skipping\n",
argv[0], dp->d_namep);
errors++;
continue;
}
if ( id == ID_COMBINATION ) {
struct rt_comb_internal *comb;
char *ptr;
comb = (struct rt_comb_internal *)intern.idb_ptr;
RT_CK_COMB( comb );
/* Convert "plastic" to "phong" in the shader string */
while ( (ptr=strstr( bu_vls_addr( &comb->shader), "plastic" )) != NULL ) {
ptr[0] = 'p'; /* p */
ptr[1] = 'h'; /* l */
ptr[2] = 'o'; /* a */
ptr[3] = 'n'; /* s */
ptr[4] = 'g'; /* t */
ptr[5] = ' '; /* i */
ptr[6] = ' '; /* c */
}
}
if ( id == ID_HF ) {
if (rt_hf_to_dsp( &intern )) {
fprintf(stderr,
"%s: Conversion from HF to DSP failed for solid %s\n",
argv[0], dp->d_namep );
errors++;
continue;
}
}
if ( id == ID_POLY)
{
if ( rt_pg_to_bot( &intern, &tol, &rt_uniresource ) )
{
fprintf( stderr, "%s: Conversion from polysolid to BOT failed for solid %s\n",
argv[0], dp->d_namep );
errors++;
continue;
}
}
/* to insure null termination */
bu_strlcpy( name, dp->d_namep, sizeof(name) );
ret = wdb_put_internal( fp, name, &intern, 1.0 );
if ( ret < 0 ) {
fprintf(stderr,
"%s: wdb_put_internal(%s) failure, skipping\n",
argv[0], dp->d_namep);
rt_db_free_internal(&intern);
errors++;
continue;
}
rt_db_free_internal(&intern);
} FOR_ALL_DIRECTORY_END
wdb_close( fp );
db_close( dbip );
fprintf(stderr, "%ld objects failed to convert\n", errors);
return 0;
}
/*
* M A I N
*/
int
main(int argc, char **argv)
{
register int c;
double percent;
bu_setlinebuf( stderr );
#if MEMORY_LEAK_CHECKING
rt_g.debug |= DEBUG_MEM_FULL;
#endif
tree_state = rt_initial_tree_state; /* struct copy */
tree_state.ts_tol = &tol;
tree_state.ts_ttol = &ttol;
tree_state.ts_m = &the_model;
ttol.magic = RT_TESS_TOL_MAGIC;
/* Defaults, updated by command line options. */
ttol.abs = 0.0;
ttol.rel = 0.01;
ttol.norm = 0.0;
/* XXX These need to be improved */
tol.magic = BN_TOL_MAGIC;
tol.dist = 0.005;
tol.dist_sq = tol.dist * tol.dist;
tol.perp = 1e-5;
tol.para = 1 - tol.perp;
rt_init_resource( &rt_uniresource, 0, NULL );
the_model = nmg_mm();
BU_LIST_INIT( &rt_g.rtg_vlfree ); /* for vlist macros */
/* Get command line arguments. */
while ((c = bu_getopt(argc, argv, "mua:n:o:r:vx:D:P:X:e:i")) != EOF) {
switch (c) {
case 'm': /* include 'usemtl' statements */
usemtl = 1;
break;
case 'u': /* Include vertexuse normals */
do_normals = 1;
break;
case 'a': /* Absolute tolerance. */
ttol.abs = atof(bu_optarg);
ttol.rel = 0.0;
break;
case 'n': /* Surface normal tolerance. */
ttol.norm = atof(bu_optarg);
ttol.rel = 0.0;
break;
case 'o': /* Output file name. */
output_file = bu_optarg;
break;
case 'r': /* Relative tolerance. */
ttol.rel = atof(bu_optarg);
break;
case 'v':
verbose++;
break;
case 'P':
ncpu = atoi( bu_optarg );
rt_g.debug = 1; /* XXX DEBUG_ALLRAYS -- to get core dumps */
break;
case 'x':
sscanf( bu_optarg, "%x", (unsigned int *)&rt_g.debug );
break;
case 'D':
tol.dist = atof(bu_optarg);
tol.dist_sq = tol.dist * tol.dist;
rt_pr_tol( &tol );
break;
case 'X':
sscanf( bu_optarg, "%x", (unsigned int *)&rt_g.NMG_debug );
NMG_debug = rt_g.NMG_debug;
break;
case 'e': /* Error file name. */
error_file = bu_optarg;
break;
case 'i':
inches = 1;
break;
default:
bu_exit(1, usage, argv[0]);
break;
}
}
if (bu_optind+1 >= argc) {
bu_exit(1, usage, argv[0]);
}
if ( !output_file )
fp = stdout;
else
{
/* Open output file */
if ( (fp=fopen( output_file, "wb+" )) == NULL )
{
perror( argv[0] );
bu_exit(1, "Cannot open output file (%s) for writing\n", output_file );
}
}
/* Open g-obj error log file */
if (!error_file) {
fpe = stderr;
#if defined(_WIN32) && !defined(__CYGWIN__)
setmode(fileno(fpe), O_BINARY);
#endif
} else if ((fpe=fopen(error_file, "wb")) == NULL) {
perror( argv[0] );
bu_exit(1, "Cannot open output file (%s) for writing\n", error_file );
}
/* Open BRL-CAD database */
argc -= bu_optind;
argv += bu_optind;
if ((dbip = db_open(argv[0], "r")) == DBI_NULL) {
perror(argv[0]);
bu_exit(1, "Unable to open geometry file (%s) for reading\n", argv[0]);
}
if ( db_dirbuild( dbip ) ) {
bu_exit(1, "db_dirbuild failed\n");
}
BN_CK_TOL(tree_state.ts_tol);
RT_CK_TESS_TOL(tree_state.ts_ttol);
/* Write out header */
if (inches)
fprintf(fp, "# BRL-CAD generated Wavefront OBJ file (Units in)\n");
else
fprintf(fp, "# BRL-CAD generated Wavefront OBJ file (Units mm)\n");
fprintf( fp, "# BRL-CAD model: %s\n# BRL_CAD objects:", argv[0] );
for ( c=1; c<argc; c++ )
fprintf( fp, " %s", argv[c] );
fprintf( fp, "\n" );
/* Walk indicated tree(s). Each region will be output separately */
(void) db_walk_tree(dbip, argc-1, (const char **)(argv+1),
1, /* ncpu */
&tree_state,
0, /* take all regions */
do_region_end,
nmg_booltree_leaf_tess,
(genptr_t)NULL); /* in librt/nmg_bool.c */
percent = 0;
if (regions_tried>0) {
percent = ((double)regions_converted * 100) / regions_tried;
printf("Tried %d regions, %d converted to NMG's successfully. %g%%\n",
regions_tried, regions_converted, percent);
}
percent = 0;
if ( regions_tried > 0 ) {
percent = ((double)regions_written * 100) / regions_tried;
printf( " %d triangulated successfully. %g%%\n",
regions_written, percent );
}
fclose(fp);
/* Release dynamic storage */
nmg_km(the_model);
rt_vlist_cleanup();
db_close(dbip);
#if MEMORY_LEAK_CHECKING
bu_prmem("After complete G-ACAD conversion");
#endif
return 0;
}
int
main(int argc, char **argv)
{
int i = 0;
int diff_state = 0;
struct bu_ptbl results;
struct db_i *dbip1 = DBI_NULL;
struct db_i *dbip2 = DBI_NULL;
/*struct bu_vls diff_log = BU_VLS_INIT_ZERO;*/
struct bn_tol *diff_tol;
BU_GET(diff_tol, struct bn_tol);
diff_tol->dist = BN_TOL_DIST;
BU_PTBL_INIT(&results);
if (argc != 3) {
bu_log("Error - please specify two .g files\n");
bu_exit(EXIT_FAILURE, NULL);
}
if (!bu_file_exists(argv[1], NULL)) {
bu_exit(1, "Cannot stat file %s\n", argv[1]);
}
if (!bu_file_exists(argv[2], NULL)) {
bu_exit(1, "Cannot stat file %s\n", argv[2]);
}
if ((dbip1 = db_open(argv[1], DB_OPEN_READONLY)) == DBI_NULL) {
bu_exit(1, "Cannot open geometry database file %s\n", argv[1]);
}
RT_CK_DBI(dbip1);
if (db_dirbuild(dbip1) < 0) {
db_close(dbip1);
bu_exit(1, "db_dirbuild failed on geometry database file %s\n", argv[1]);
}
/* Reset the material head so we don't get warnings when the global
* is overwritten. This will go away when material_head ceases to
* be a librt global.*/
rt_new_material_head(MATER_NULL);
if ((dbip2 = db_open(argv[2], DB_OPEN_READONLY)) == DBI_NULL) {
bu_exit(1, "Cannot open geometry database file %s\n", argv[2]);
}
RT_CK_DBI(dbip2);
if (db_dirbuild(dbip2) < 0) {
db_close(dbip1);
db_close(dbip2);
bu_exit(1, "db_dirbuild failed on geometry database file %s\n", argv[1]);
}
diff_state = db_diff(dbip1, dbip2, diff_tol, DB_COMPARE_ALL, &results);
if (diff_state == DIFF_UNCHANGED) {
bu_log("No differences found.\n");
} else {
print_diff_summary(&results);
}
for (i = 0; i < (int)BU_PTBL_LEN(&results); i++) {
struct diff_result *result = (struct diff_result *)BU_PTBL_GET(&results, i);
diff_free_result(result);
}
bu_ptbl_free(&results);
BU_PUT(diff_tol, struct bn_tol);
db_close(dbip1);
db_close(dbip2);
return 0;
}
int
ged_concat(struct ged *gedp, int argc, const char *argv[])
{
struct db_i *newdbp;
struct directory *dp;
Tcl_HashTable name_tbl;
Tcl_HashTable used_names_tbl;
Tcl_HashEntry *ptr;
Tcl_HashSearch search;
struct bu_attribute_value_set g_avs;
const char *cp;
char *colorTab;
struct ged_concat_data cc_data;
const char *oldfile;
static const char *usage = "[-u] [-t] [-c] [-s|-p] file.g [suffix|prefix]";
int importUnits = 0;
int importTitle = 0;
int importColorTable = 0;
int saveGlobalAttrs = 0;
int c;
const char *commandName;
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_READ_ONLY(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
if (argc < 2) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
bu_vls_init(&cc_data.affix);
cc_data.copy_mode = 0;
commandName = argv[0];
/* process args */
bu_optind = 1;
bu_opterr = 0;
while ((c=bu_getopt(argc, (char * const *)argv, "utcsp")) != -1) {
switch (c) {
case 'u':
importUnits = 1;
break;
case 't':
importTitle = 1;
break;
case 'c':
importColorTable = 1;
break;
case 'p':
cc_data.copy_mode |= AUTO_PREFIX;
break;
case 's':
cc_data.copy_mode |= AUTO_SUFFIX;
break;
default: {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", commandName, usage);
bu_vls_free(&cc_data.affix);
return GED_ERROR;
}
}
}
argc -= bu_optind;
argv += bu_optind;
if (argc == 0) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", commandName, usage);
return GED_ERROR;
}
oldfile = argv[0];
argc--;
argv++;
if (cc_data.copy_mode) {
/* specified suffix or prefix explicitly */
if (cc_data.copy_mode & AUTO_PREFIX) {
if (argc == 0 || BU_STR_EQUAL(argv[0], "/")) {
cc_data.copy_mode = NO_AFFIX | CUSTOM_PREFIX;
} else {
(void)bu_vls_strcpy(&cc_data.affix, argv[0]);
cc_data.copy_mode |= CUSTOM_PREFIX;
}
} else if (cc_data.copy_mode & AUTO_SUFFIX) {
if (argc == 0 || BU_STR_EQUAL(argv[0], "/")) {
cc_data.copy_mode = NO_AFFIX | CUSTOM_SUFFIX;
} else {
(void)bu_vls_strcpy(&cc_data.affix, argv[0]);
cc_data.copy_mode |= CUSTOM_SUFFIX;
}
} else {
bu_vls_free(&cc_data.affix);
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", commandName, usage);
return GED_ERROR;
}
} else {
/* no prefix/suffix preference, use prefix */
cc_data.copy_mode |= AUTO_PREFIX;
if (argc == 0 || BU_STR_EQUAL(argv[0], "/")) {
cc_data.copy_mode = NO_AFFIX | CUSTOM_PREFIX;
} else {
(void)bu_vls_strcpy(&cc_data.affix, argv[0]);
cc_data.copy_mode |= CUSTOM_PREFIX;
}
}
if (db_version(gedp->ged_wdbp->dbip) < 5) {
if (bu_vls_strlen(&cc_data.affix) > _GED_V4_MAXNAME-1) {
bu_log("ERROR: affix [%s] is too long for v%d\n", bu_vls_addr(&cc_data.affix), db_version(gedp->ged_wdbp->dbip));
bu_vls_free(&cc_data.affix);
return GED_ERROR;
}
}
/* open the input file */
if ((newdbp = db_open(oldfile, DB_OPEN_READONLY)) == DBI_NULL) {
bu_vls_free(&cc_data.affix);
perror(oldfile);
bu_vls_printf(gedp->ged_result_str, "%s: Can't open geometry database file %s", commandName, oldfile);
return GED_ERROR;
}
if (db_version(newdbp) > 4 && db_version(gedp->ged_wdbp->dbip) < 5) {
bu_vls_free(&cc_data.affix);
bu_vls_printf(gedp->ged_result_str, "%s: databases are incompatible, use dbupgrade on %s first",
commandName, gedp->ged_wdbp->dbip->dbi_filename);
return GED_ERROR;
}
db_dirbuild(newdbp);
cc_data.new_dbip = newdbp;
cc_data.old_dbip = gedp->ged_wdbp->dbip;
/* visit each directory pointer in the input database */
Tcl_InitHashTable(&name_tbl, TCL_STRING_KEYS);
Tcl_InitHashTable(&used_names_tbl, TCL_STRING_KEYS);
if (importUnits || importTitle || importColorTable) {
saveGlobalAttrs = 1;
}
FOR_ALL_DIRECTORY_START(dp, newdbp) {
if (dp->d_major_type == DB5_MAJORTYPE_ATTRIBUTE_ONLY) {
if (saveGlobalAttrs) {
if (db5_get_attributes(newdbp, &g_avs, dp)) {
bu_vls_printf(gedp->ged_result_str, "%s: Can't get global attributes from %s", commandName, oldfile);
return GED_ERROR;
}
}
continue;
}
copy_object(gedp, dp, newdbp, gedp->ged_wdbp->dbip, &name_tbl, &used_names_tbl, &cc_data);
} FOR_ALL_DIRECTORY_END;
bu_vls_free(&cc_data.affix);
rt_mempurge(&(newdbp->dbi_freep));
/* Free all the directory entries, and close the input database */
db_close(newdbp);
if (importColorTable) {
colorTab = bu_strdup(bu_avs_get(&g_avs, "regionid_colortable"));
db5_import_color_table(colorTab);
bu_free(colorTab, "colorTab");
} else if (saveGlobalAttrs) {
bu_avs_remove(&g_avs, "regionid_colortable");
}
if (importTitle) {
if ((cp = bu_avs_get(&g_avs, "title")) != NULL) {
char *oldTitle = gedp->ged_wdbp->dbip->dbi_title;
gedp->ged_wdbp->dbip->dbi_title = bu_strdup(cp);
if (oldTitle) {
bu_free(oldTitle, "old title");
}
}
} else if (saveGlobalAttrs) {
bu_avs_remove(&g_avs, "title");
}
if (importUnits) {
if ((cp = bu_avs_get(&g_avs, "units")) != NULL) {
double dd;
if (sscanf(cp, "%lf", &dd) != 1 || NEAR_ZERO(dd, VUNITIZE_TOL)) {
bu_log("copy_object(%s): improper database, %s object attribute 'units'=%s is invalid\n",
oldfile, DB5_GLOBAL_OBJECT_NAME, cp);
bu_avs_remove(&g_avs, "units");
} else {
gedp->ged_wdbp->dbip->dbi_local2base = dd;
gedp->ged_wdbp->dbip->dbi_base2local = 1 / dd;
}
}
} else if (saveGlobalAttrs) {
bu_avs_remove(&g_avs, "units");
}
if (saveGlobalAttrs) {
dp = db_lookup(gedp->ged_wdbp->dbip, DB5_GLOBAL_OBJECT_NAME, LOOKUP_NOISY);
db5_update_attributes(dp, &g_avs, gedp->ged_wdbp->dbip);
}
db_sync(gedp->ged_wdbp->dbip); /* force changes to disk */
/* Free the Hash tables */
ptr = Tcl_FirstHashEntry(&name_tbl, &search);
while (ptr) {
bu_free((char *)Tcl_GetHashValue(ptr), "new name");
ptr = Tcl_NextHashEntry(&search);
}
Tcl_DeleteHashTable(&name_tbl);
Tcl_DeleteHashTable(&used_names_tbl);
return GED_OK;
}
/**
* P O P _ S P A W N --- spawn a new population
* TODO: generalize/modularize somehow to allow adding more shapes and primitives
* also use variable/defined rates, intersection with bounding box, etc...
*/
void
pop_spawn (struct population *p)
{
int i, j;
point_t p1/*, p2, p3*/;
struct wmember wm_hd;
double r1/*, r2, r3*/;
char shape[256];
p->db_p = db_create("gen000", 5);
p->db_p->dbi_wdbp = wdb_dbopen(p->db_p, RT_WDB_TYPE_DB_DISK);
for (i = 0; i < p->size; i++) {
p->name[i] = bu_malloc(sizeof(char) * 256, "name");
snprintf(p->name[i], 256, "ind%.3d", i);
BU_LIST_INIT(&wm_hd.l);
/*
VSET(p1, -5, -5, -5);
VSET(p2, 5, 5, 5);
r1 = r2 = 2.5;
*/
for (j = 0; j < 6; j++) {
/* VSETALL(p1, -10+pop_rand()*10); */
p1[0] = -10*pop_rand()*10;
p1[1] = -10*pop_rand()*10;
p1[2] = -10*pop_rand()*10;
r1 = 1+3*pop_rand();
snprintf(shape, 256, "ind%.3d-%.3d", i, j);
mk_sph(p->db_p->dbi_wdbp, shape, p1, r1);
mk_addmember(shape, &wm_hd.l, NULL, WMOP_UNION);
}
p->parent[i].fitness = 0.0;
p->parent[i].id = i;
/*
snprintf(shape, 256, "ind%.3d-%.3d", i, 0);
mk_sph(p->db_p->dbi_wdbp, shape, p1, r1);
mk_addmember(shape, &wm_hd.l, NULL, WMOP_UNION);
snprintf(shape, 256, "ind%.3d-%.3d", i, 1);
mk_sph(p->db_p->dbi_wdbp, shape, p2, r2);
mk_addmember(shape, &wm_hd.l, NULL, WMOP_UNION);
snprintf(shape, 256, "gen%.3dind%.3d-%.3d", 0, i, 2);
mk_sph(p->db_p->dbi_wdbp, shape, p3, r3);
mk_addmember(shape, &wm_hd.l, NULL, WMOP_UNION);
*/
mk_lcomb(p->db_p->dbi_wdbp, NL_P(p->parent[i].id), &wm_hd, 1, NULL, NULL, NULL, 0);
}
/*
* reload the db so we dont
* have to do any extra checks
* in the main loop
*/
wdb_close(p->db_p->dbi_wdbp);
if ((p->db_p = db_open("gen000", "r")) == DBI_NULL)
bu_exit(EXIT_FAILURE, "Failed to re-open initial population");
if (db_dirbuild(p->db_p) < 0)
bu_exit(EXIT_FAILURE, "Failed to load initial database");
}
int
rt_mk_binunif(struct rt_wdb *wdbp, const char *obj_name, const char *file_name, unsigned int minor_type, size_t max_count)
{
int ret;
struct stat st;
size_t num_items = 0;
size_t obj_length = 0;
size_t item_length = 0;
unsigned int major_type = DB5_MAJORTYPE_BINARY_UNIF;
struct directory *dp = NULL;
struct bu_mapped_file *bu_fd = NULL;
struct rt_binunif_internal *bip = NULL;
struct bu_external body;
struct bu_external bin_ext;
struct rt_db_internal intern;
item_length = db5_type_sizeof_h_binu(minor_type);
if (item_length == 0) {
bu_log("Unrecognized minor type (%d)!\n", minor_type);
return -1;
}
if (bu_stat(file_name, &st)) {
bu_log("Cannot stat input file (%s)", file_name);
return -1;
}
bu_fd = bu_open_mapped_file(file_name, NULL);
if (bu_fd == NULL) {
bu_log("Cannot open input file (%s) for reading", file_name);
return -1;
}
/* create the rt_binunif internal form */
BU_ALLOC(bip, struct rt_binunif_internal);
bip->magic = RT_BINUNIF_INTERNAL_MAGIC;
bip->type = minor_type;
num_items = (size_t)(st.st_size / item_length);
/* maybe only a partial file read */
if (max_count > 0 && max_count < num_items) {
num_items = max_count;
}
obj_length = num_items * item_length;
if (obj_length < 1) {
obj_length = 1;
}
/* just copy the bytes */
bip->count = (long)num_items;
bip->u.int8 = (char *)bu_malloc(obj_length, "binary uniform object");
memcpy(bip->u.int8, bu_fd->buf, obj_length);
bu_close_mapped_file(bu_fd);
/* create the rt_internal form */
RT_DB_INTERNAL_INIT(&intern);
intern.idb_major_type = major_type;
intern.idb_minor_type = minor_type;
intern.idb_ptr = (genptr_t)bip;
intern.idb_meth = &rt_functab[ID_BINUNIF];
/* create body portion of external form */
ret = -1;
if (intern.idb_meth->ft_export5) {
ret = intern.idb_meth->ft_export5(&body, &intern, 1.0, wdbp->dbip, wdbp->wdb_resp);
}
if (ret != 0) {
bu_log("Error while attempting to export %s\n", obj_name);
rt_db_free_internal(&intern);
return -1;
}
/* create entire external form */
db5_export_object3(&bin_ext, DB5HDR_HFLAGS_DLI_APPLICATION_DATA_OBJECT,
obj_name, 0, NULL, &body,
intern.idb_major_type, intern.idb_minor_type,
DB5_ZZZ_UNCOMPRESSED, DB5_ZZZ_UNCOMPRESSED);
rt_db_free_internal(&intern);
bu_free_external(&body);
/* make sure the database directory is initialized */
if (wdbp->dbip->dbi_eof == RT_DIR_PHONY_ADDR) {
ret = db_dirbuild(wdbp->dbip);
if (ret) {
return -1;
}
}
/* add this (phony until written) object to the directory */
if ((dp=db_diradd5(wdbp->dbip, obj_name, RT_DIR_PHONY_ADDR, major_type,
minor_type, 0, 0, NULL)) == RT_DIR_NULL) {
bu_log("Error while attempting to add new name (%s) to the database",
obj_name);
bu_free_external(&bin_ext);
return -1;
}
/* and write it to the database */
if (db_put_external5(&bin_ext, dp, wdbp->dbip)) {
bu_log("Error while adding new binary object (%s) to the database",
obj_name);
bu_free_external(&bin_ext);
return -1;
}
bu_free_external(&bin_ext);
return 0;
}
int
main(int argc, char **argv)
{
struct directory *dp;
if (argc != 3 && argc != 4) {
bu_exit(1, "Usage:\n\t%s [-v] input.g output.g\n", argv[0]);
}
if (argc == 4) {
if (BU_STR_EQUAL(argv[1], "-v"))
verbose = 1;
else {
bu_log("Illegal option: %s\n", argv[1]);
bu_exit(1, "Usage:\n\t%s [-v] input.g output.g\n", argv[0]);
}
}
rt_init_resource(&rt_uniresource, 0, NULL);
dbip = db_open(argv[argc-2], DB_OPEN_READONLY);
if (dbip == DBI_NULL) {
perror(argv[0]);
bu_exit(1, "Cannot open geometry database file (%s)\n", argv[argc-2]);
}
if ((fdout=wdb_fopen(argv[argc-1])) == NULL) {
perror(argv[0]);
bu_exit(1, "Cannot open file (%s)\n", argv[argc-1]);
}
if (db_dirbuild(dbip)) {
bu_exit(1, "db_dirbuild failed\n");
}
/* Visit all records in input database, and spew them out,
* modifying NMG objects into BoTs.
*/
FOR_ALL_DIRECTORY_START(dp, dbip) {
struct rt_db_internal intern;
int id;
int ret;
id = rt_db_get_internal(&intern, dp, dbip, NULL, &rt_uniresource);
if (id < 0) {
fprintf(stderr,
"%s: rt_db_get_internal(%s) failure, skipping\n",
argv[0], dp->d_namep);
continue;
}
if (id == ID_NMG) {
nmg_conv(&intern, dp->d_namep);
} else {
ret = wdb_put_internal(fdout, dp->d_namep, &intern, 1.0);
if (ret < 0) {
fprintf(stderr,
"%s: wdb_put_internal(%s) failure, skipping\n",
argv[0], dp->d_namep);
rt_db_free_internal(&intern);
continue;
}
}
rt_db_free_internal(&intern);
} FOR_ALL_DIRECTORY_END
wdb_close(fdout);
return 0;
}
int
main(int argc, char *argv[])
{
int verbose = 0;
int ncpu = 1; /* Number of processors */
char *output_file = NULL; /* output filename */
struct db_i *dbip;
struct model *the_model;
struct rt_tess_tol ttol; /* tessellation tolerance in mm */
struct db_tree_state tree_state; /* includes tol & model */
int i, use_mc = 0, use_bottess = 0;
struct egg_conv_data conv_data;
struct gcv_region_end_data gcvwriter = {nmg_to_egg, NULL};
gcvwriter.client_data = (void *)&conv_data;
bu_setprogname(argv[0]);
bu_setlinebuf(stderr);
tree_state = rt_initial_tree_state; /* struct copy */
tree_state.ts_tol = &conv_data.tol;
tree_state.ts_ttol = &ttol;
tree_state.ts_m = &the_model;
/* Set up tessellation tolerance defaults */
ttol.magic = RT_TESS_TOL_MAGIC;
/* Defaults, updated by command line options. */
ttol.abs = 0.0;
ttol.rel = 0.01;
ttol.norm = 0.0;
/* Set up calculation tolerance defaults */
/* FIXME: These need to be improved */
conv_data.tol.magic = BN_TOL_MAGIC;
conv_data.tol.dist = BN_TOL_DIST;
conv_data.tol.dist_sq = conv_data.tol.dist * conv_data.tol.dist;
conv_data.tol.perp = 1e-6;
conv_data.tol.para = 1 - conv_data.tol.perp;
conv_data.tot_polygons = 0;
/* make empty NMG model */
the_model = nmg_mm();
BU_LIST_INIT(&RTG.rtg_vlfree); /* for vlist macros */
/* Get command line arguments. */
while ((i = bu_getopt(argc, argv, "a:89n:o:r:vx:D:P:X:h?")) != -1) {
switch (i) {
case 'a': /* Absolute tolerance. */
ttol.abs = atof(bu_optarg);
ttol.rel = 0.0;
break;
case 'n': /* Surface normal tolerance. */
ttol.norm = atof(bu_optarg);
ttol.rel = 0.0;
break;
case 'o': /* Output file name. */
output_file = bu_optarg;
break;
case 'r': /* Relative tolerance. */
ttol.rel = atof(bu_optarg);
break;
case 'v':
verbose++;
break;
case 'P':
ncpu = atoi(bu_optarg);
break;
case 'x':
sscanf(bu_optarg, "%x", (unsigned int *)&RTG.debug);
break;
case 'D':
conv_data.tol.dist = atof(bu_optarg);
conv_data.tol.dist_sq = conv_data.tol.dist * conv_data.tol.dist;
rt_pr_tol(&conv_data.tol);
break;
case 'X':
sscanf(bu_optarg, "%x", (unsigned int *)&RTG.NMG_debug);
break;
case '8':
use_mc = 1;
break;
case '9':
use_bottess = 1;
break;
default:
usage(argv[0]);
}
}
if (bu_optind+1 >= argc)
usage(argv[0]);
conv_data.fp = stdout;
if (output_file) {
if ((conv_data.fp=fopen(output_file, "wb+")) == NULL) {
perror(argv[0]);
bu_exit(1, "Cannot open ASCII output file (%s) for writing\n", output_file);
}
}
/* Open brl-cad database */
argc -= bu_optind;
argv += bu_optind;
if (argc < 2 || argv[0] == NULL || argv[1] == NULL)
usage(argv[0]);
gcvwriter.write_region = nmg_to_egg;
if ((dbip = db_open(argv[0], DB_OPEN_READONLY)) == DBI_NULL) {
perror(argv[0]);
bu_exit(1, "Unable to open geometry database file (%s)\n", argv[0]);
}
if (db_dirbuild(dbip)) {
bu_exit(1, "ERROR: db_dirbuild failed\n");
}
BN_CK_TOL(tree_state.ts_tol);
RT_CK_TESS_TOL(tree_state.ts_ttol);
if (verbose) {
bu_log("Model: %s\n", argv[0]);
bu_log("Objects:");
for (i=1; i<argc; i++)
bu_log(" %s", argv[i]);
bu_log("\nTessellation tolerances:\n\tabs = %g mm\n\trel = %g\n\tnorm = %g\n",
tree_state.ts_ttol->abs, tree_state.ts_ttol->rel, tree_state.ts_ttol->norm);
bu_log("Calculational tolerances:\n\tdist = %g mm perp = %g\n",
tree_state.ts_tol->dist, tree_state.ts_tol->perp);
}
/* print the egg header stuff, including the command line to execute it */
fprintf(conv_data.fp, "<CoordinateSystem> { Z-Up }\n\n");
fprintf(conv_data.fp, "<Comment> {\n \"%s", *argv);
for (i=1; i<argc; i++)
fprintf(conv_data.fp, " %s", argv[i]);
fprintf(conv_data.fp, "\"\n}\n");
/* Walk indicated tree(s). Each region will be output separately */
while (--argc) {
fprintf(conv_data.fp, "<Group> %s {\n", *(argv+1));
(void) db_walk_tree(dbip, /* db_i */
1, /* argc */
(const char **)(++argv), /* argv */
ncpu, /* ncpu */
&tree_state, /* state */
NULL, /* start func */
use_mc?gcv_region_end_mc:use_bottess?gcv_bottess_region_end:gcv_region_end, /* end func */
use_mc?NULL:nmg_booltree_leaf_tess, /* leaf func */
(void *)&gcvwriter); /* client_data */
fprintf(conv_data.fp, "}\n");
}
bu_log("%ld triangles written\n", conv_data.tot_polygons);
if (output_file)
fclose(conv_data.fp);
/* Release dynamic storage */
nmg_km(the_model);
rt_vlist_cleanup();
db_close(dbip);
return 0;
}
int
main(int argc, char *argv[])
{
size_t i;
int ret;
int c;
double percent;
char copy_buffer[CP_BUF_SIZE] = {0};
struct directory *dp;
bu_setprogname(argv[0]);
bu_setlinebuf(stderr);
bu_log("%s", brlcad_ident("BRL-CAD to IGES Translator"));
bu_log("Please direct bug reports to <*****@*****.**>\n\n");
tree_state = rt_initial_tree_state; /* struct copy */
tree_state.ts_tol = &tol;
tree_state.ts_ttol = &ttol;
tree_state.ts_m = &the_model;
ttol.magic = RT_TESS_TOL_MAGIC;
/* Defaults, updated by command line options. */
ttol.abs = 0.0;
ttol.rel = 0.01;
ttol.norm = 0.0;
/* FIXME: These need to be improved */
tol.magic = BN_TOL_MAGIC;
tol.dist = 0.0005;
tol.dist_sq = tol.dist * tol.dist;
tol.perp = 1e-6;
tol.para = 1 - tol.perp;
the_model = nmg_mm();
BU_LIST_INIT(&RTG.rtg_vlfree); /* for vlist macros */
rt_init_resource(&rt_uniresource, 0, NULL);
prog_name = argv[0];
/* Get command line arguments. */
while ((c = bu_getopt(argc, argv, "ftsmd:a:n:o:p:r:vx:P:X:")) != -1) {
switch (c) {
case 'f': /* Select facetized output */
mode = FACET_MODE;
multi_file = 0;
break;
case 't':
mode = TRIMMED_SURF_MODE;
multi_file = 0;
break;
case 'm': /* multi-file mode */
multi_file = 1;
mode = TRIMMED_SURF_MODE;
break;
case 's': /* Select NURB output */
do_nurbs = 1;
break;
case 'v':
verbose++;
break;
case 'a': /* Absolute tolerance. */
ttol.abs = atof(bu_optarg);
break;
case 'r': /* Relative tolerance. */
ttol.rel = atof(bu_optarg);
break;
case 'n': /* Surface normal tolerance. */
ttol.norm = atof(bu_optarg);
break;
case 'd': /* distance tolerance */
tol.dist = atof(bu_optarg);
tol.dist_sq = tol.dist * tol.dist;
break;
case 'x':
sscanf(bu_optarg, "%x", (unsigned int *)&RTG.debug);
break;
case 'X':
sscanf(bu_optarg, "%x", (unsigned int *)&RTG.NMG_debug);
NMG_debug = RTG.NMG_debug;
break;
case 'o': /* Output file name. */
output_file = bu_optarg;
break;
case 'P':
ncpu = atoi(bu_optarg);
break;
default:
usage(argv[0]);
break;
}
}
if (bu_optind+1 >= argc) {
usage(argv[0]);
}
/* Open BRL-CAD database */
argc -= bu_optind;
argv += bu_optind;
db_name = argv[0];
if ((DBIP = db_open(db_name, DB_OPEN_READONLY)) == DBI_NULL) {
perror("g-iges");
bu_exit(1, "ERROR: unable to open geometry database file (%s)\n", db_name);
}
/* Scan the database */
if (db_dirbuild(DBIP)) {
bu_exit(1, "db_dirbuild failed\n");
}
if (!multi_file) {
/* let the IGES routines know the selected tolerances and the database pointer */
iges_init(&tol, &ttol, verbose, DBIP);
/* Open the output file */
if (output_file == NULL)
fp_dir = stdout;
else {
if ((fp_dir = fopen(output_file, "wb")) == NULL) {
perror(output_file);
bu_exit(1, "Cannot open output file: %s\n", output_file);
}
}
/* 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");
}
/* Write start and global sections of the IGES file */
w_start_global(fp_dir, fp_param, argv[0], prog_name, output_file, __DATE__, brlcad_version());
} else {
if (!bu_file_directory(output_file)) {
bu_exit(1, "-o option must provide a directory, %s is not a directory\n", output_file);
}
}
/* Count object references */
/* for (i = 1; i < argc; i++) {
dp = db_lookup(DBIP, argv[i], 1);
db_functree(DBIP, dp, count_refs, 0, NULL);
} */
/* tree tops must have independent status, so we need to remember them */
independent = (argv+1);
no_of_indeps = (size_t)argc-1;
if (mode == FACET_MODE) {
/* Walk indicated tree(s). Each region will be output
* as a single manifold solid BREP object */
ret = db_walk_tree(DBIP, argc-1, (const char **)(argv+1),
ncpu,
&tree_state,
0, /* take all regions */
do_nmg_region_end,
nmg_booltree_leaf_tess,
(void *)NULL); /* in librt/nmg_bool.c */
if (ret)
bu_exit(1, "g-iges: Could not facetize anything!");
if (!multi_file) {
/* Now walk the same trees again, but only output groups */
for (i = 1; i < (size_t)argc; i++) {
char *ptr;
ptr = strrchr(argv[i], '/');
if (ptr != NULL) {
ptr++;
} else {
ptr = argv[i];
}
dp = db_lookup(DBIP, ptr, 1);
if (!dp) {
bu_log("WARNING: Unable to locate %s in %s\n, skipping\n", ptr, db_name);
continue;
}
db_functree(DBIP, dp, csg_comb_func, 0, &rt_uniresource, NULL);
}
}
} else if (mode == CSG_MODE) {
/* Walk indicated tree(s). Each combination and solid will be output
* as a CSG object, unless there is no IGES equivalent (then the
* solid will be tessellated and output as a BREP object) */
for (i = 1; i < (size_t)argc; i++) {
dp = db_lookup(DBIP, argv[i], 1);
if (!dp) {
bu_log("WARNING: Unable to locate %s in %s\n, skipping\n", argv[i], db_name);
continue;
}
db_functree(DBIP, dp, csg_comb_func, csg_leaf_func, &rt_uniresource, NULL);
}
} else if (mode == TRIMMED_SURF_MODE) {
/* Walk the indicated tree(s). Each region is output as a collection
* of trimmed NURBS */
ret = db_walk_tree(DBIP, argc-1, (const char **)(argv+1),
ncpu,
&tree_state,
0, /* take all regions */
do_nmg_region_end,
nmg_booltree_leaf_tess,
(void *)NULL); /* in librt/nmg_bool.c */
if (ret)
bu_exit(1, "g-iges: Could not facetize anything!");
}
if (!multi_file) {
/* 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);
}
/* Print some statistics */
Print_stats(stdout);
/* report on the success rate for facetizing regions */
if (mode == FACET_MODE || mode == TRIMMED_SURF_MODE) {
percent = 0;
if (regions_tried>0) percent = ((double)regions_done * 100) / regions_tried;
bu_log("Tried %d regions, %d converted to nmg's successfully. %g%%\n",
regions_tried, regions_done, percent);
}
/* re-iterate warnings */
if (scale_error || solid_error || comb_error)
bu_log("WARNING: the IGES file produced has errors:\n");
if (scale_error)
bu_log("\t%d scaled objects found, written to IGES file without being scaled\n", scale_error);
if (solid_error)
bu_log("\t%d solids were not converted to IGES format\n", solid_error);
if (comb_error)
bu_log("\t%d combinations were not converted to IGES format\n", comb_error);
return 0;
}
int main(int argc, char *argv[]) {
int i, g; /* generation and parent counters */
int parent1, parent2;
int gop;
fastf_t total_fitness = 0.0f;
struct fitness_state fstate;
struct population pop = {NULL, NULL, NULL, NULL, NULL, 0};
char dbname[256] = {0};
struct beset_options opts = {DEFAULT_POP_SIZE, DEFAULT_GENS, DEFAULT_RES, 0, 0, 0, 0};
struct individual *tmp = NULL;
int ac;
struct db_i *source_db;
ac = parse_args(argc, argv, &opts);
if (argc - ac != 3)
usage();
/* read source model into fstate.rays */
fit_prep(&fstate, opts.res, opts.res);
fit_store(argv[ac+2], argv[ac+1], &fstate);
/* initialize population and spawn initial individuals */
pop_init(&pop, opts.pop_size);
pop_spawn(&pop);
source_db = db_open(argv[ac+1], DB_OPEN_READWRITE);
db_dirbuild(source_db);
pop.db_c = db_create("testdb", 5);
db_close(pop.db_c);
for (g = 1; g < opts.gens; g++ ) {
#ifdef VERBOSE
printf("\nGeneration %d:\n"
"--------------\n", g);
#endif
total_fitness = 0.0f;
snprintf(dbname, 256, "gen%.3d", g);
pop.db_c = db_create(dbname, 5);
pop_gop(REPRODUCE, argv[ac+2], NULL, argv[ac+2], NULL, source_db, pop.db_c, &rt_uniresource);
/* calculate sum of all fitnesses and find
* the most fit individual in the population
* note: need to calculate outside of main pop
* loop because it's needed for pop_wrand_ind()*/
for (i = 0; i < pop.size; i++) {
fit_diff(NL(pop.parent[i].id), pop.db_p, &fstate);
pop.parent[i].fitness = fstate.fitness;
total_fitness += FITNESS;
}
/* sort population - used for keeping top N and dropping bottom M */
bu_sort((void *)pop.parent, pop.size, sizeof(struct individual), cmp_ind, NULL);
/* remove lower M of individuals */
for (i = 0; i < opts.kill_lower; i++) {
total_fitness -= pop.parent[i].fitness;
}
printf("Most fit from %s was %s with a fitness of %g\n", dbname, NL(pop.parent[pop.size-1].id), pop.parent[pop.size-1].fitness);
printf("%6.8g\t%6.8g\t%6.8g\n", total_fitness/pop.size, pop.parent[0].fitness, pop.parent[pop.size-1].fitness);
for (i = 0; i < pop.size; i++) {
pop.child[i].id = i;
/* keep upper N */
if (i >= pop.size - opts.keep_upper) {
pop_gop(REPRODUCE, NL(pop.parent[i].id), NULL, NL(pop.child[i].id), NULL,
pop.db_p, pop.db_c, &rt_uniresource);
continue;
}
/* Choose a random genetic operation and
* a parent which the op will be performed on*/
gop = pop_wrand_gop();
parent1 = pop_wrand_ind(pop.parent, pop.size, total_fitness, opts.kill_lower);
/* only need 1 more individual, can't crossover, so reproduce */
if (gop == CROSSOVER && i >= pop.size-opts.keep_upper-1)gop=REPRODUCE;
if (gop & (REPRODUCE | MUTATE)) {
#ifdef VERBOSE
printf("r(%s)\t ---------------> (%s)\n", NL(pop.parent[parent1].id), NL(pop.child[i].id));
#endif
/* perform the genetic operation and output the child to the child database */
pop_gop(gop, NL(pop.parent[parent1].id), NULL, NL(pop.child[i].id), NULL,
pop.db_p, pop.db_c, &rt_uniresource);
} else {
/* If we're performing crossover, we need a second parent */
parent2 = pop_wrand_ind(pop.parent, pop.size, total_fitness, opts.kill_lower);
++i;
pop.child[i].id = i;
#ifdef VERBOSE
printf("x(%s, %s) --> (%s, %s)\n", NL(pop.parent[parent1].id), NL(pop.parent[parent2].id), pop.child[i-1].id, pop.child[i].id);
#endif
/* perform the genetic operation and output the children to the child database */
pop_gop(gop, NL(pop.parent[parent1].id), NL(pop.parent[parent2].id), NL(pop.child[i-1].id), NL(pop.child[i].id),
pop.db_p, pop.db_c, &rt_uniresource);
}
}
/* Close parent db and move children
* to parent database and population
* Note: pop size is constant so we
* can keep the storage from the previous
* pop.parent for the next pop.child*/
db_close(pop.db_p);
pop.db_p = pop.db_c;
tmp = pop.child;
pop.child = pop.parent;
pop.parent = tmp;
}
db_close(pop.db_p);
#ifdef VERBOSE
printf("\nFINAL POPULATION\n"
"----------------\n");
for (i = 0; i < pop.size; i++)
printf("%s\tf:%.5g\n", NL(pop.child[i].id),
pop.child[i].fitness);
#endif
pop_clean(&pop);
fit_clean(&fstate);
return 0;
}
int main(int argc, char *argv[])
{
int c;
struct directory* dp;
struct db_i *dbip;
/* setup BRL-CAD environment */
bu_setprogname(argv[0]);
bu_setlinebuf(stderr);
/* process command line arguments */
while ((c = bu_getopt(argc, argv, "vo:ys:fh?")) != -1) {
switch (c) {
case 'v':
verbose++;
break;
case 'o':
out_file = bu_optarg;
break;
case 'y':
yup++;
break;
case 's':
sscanf(bu_optarg, "%f", &scale);
break;
case 'f':
flip_normals++;
break;
default:
print_usage(argv[0]);
}
}
/* param check */
if (bu_optind+1 >= argc)
print_usage(argv[0]);
/* get database filename and object */
db_file = argv[bu_optind++];
object = argv[bu_optind];
/* open BRL-CAD database */
if ((dbip = db_open(db_file, DB_OPEN_READONLY)) == DBI_NULL) {
perror(argv[0]);
bu_exit(1, "Cannot open geometry database file %s\n", db_file);
}
if (db_dirbuild(dbip))
bu_exit(1, "db_dirbuild() failed!\n");
if (verbose)
fprintf(stderr, ">> opened db '%s'\n", dbip->dbi_title);
/* setup output stream */
if (out_file == NULL) {
fp_out = stdout;
setmode(fileno(fp_out), O_BINARY);
} else {
if ((fp_out = fopen(out_file, "wb")) == NULL) {
bu_log("Cannot open %s\n", out_file);
perror(argv[0]);
return 2;
}
}
/* find requested object */
db_update_nref(dbip, &rt_uniresource);
dp = db_lookup(dbip, object, 0);
if (dp == RT_DIR_NULL)
bu_exit(1, "Object %s not found in database!\n", object);
/* generate mesh list */
db_functree(dbip, dp, NULL, mesh_tracker, &rt_uniresource, NULL);
if (verbose)
fprintf(stderr, ">> mesh count: %d\n", mesh_count);
/* write out header */
write_header(dbip);
/* write out meshes */
write_mesh_data();
/* finish */
dealloc_mesh_list();
db_close(dbip);
return 0;
}
int
main(int argc, char **argv)
{
int c;
double percent;
bu_setprogname(argv[0]);
bu_setlinebuf(stderr);
tree_state = rt_initial_tree_state; /* struct copy */
tree_state.ts_tol = &tol;
tree_state.ts_ttol = &ttol;
tree_state.ts_m = &the_model;
/* Set up tessellation tolerance defaults */
ttol.magic = RT_TESS_TOL_MAGIC;
/* Defaults, updated by command line options. */
ttol.abs = 0.0;
ttol.rel = 0.01;
ttol.norm = 0.0;
/* Set up calculation tolerance defaults */
/* FIXME: These need to be improved */
tol.magic = BN_TOL_MAGIC;
tol.dist = 0.0005;
tol.dist_sq = tol.dist * tol.dist;
tol.perp = 1e-6;
tol.para = 1 - tol.perp;
/* init resources we might need */
rt_init_resource(&rt_uniresource, 0, NULL);
/* make empty NMG model */
the_model = nmg_mm();
/* Get command line arguments. */
while ((c = bu_getopt(argc, argv, "r:a:n:o:vx:D:X:h?")) != -1) {
switch (c) {
case 'r': /* Relative tolerance. */
ttol.rel = atof(bu_optarg);
break;
case 'a': /* Absolute tolerance. */
ttol.abs = atof(bu_optarg);
ttol.rel = 0.0;
break;
case 'n': /* Surface normal tolerance. */
ttol.norm = atof(bu_optarg);
ttol.rel = 0.0;
break;
case 'o': /* Output file name. */
/* grab output file name */
break;
case 'v':
verbose++;
break;
case 'x':
sscanf(bu_optarg, "%x", (unsigned int *)&RTG.debug);
break;
case 'D':
tol.dist = atof(bu_optarg);
tol.dist_sq = tol.dist * tol.dist;
rt_pr_tol(&tol);
break;
case 'X':
sscanf(bu_optarg, "%x", (unsigned int *)&RTG.NMG_debug);
NMG_debug = RTG.NMG_debug;
break;
default:
bu_exit(1, usage, argv[0]);
}
}
if (bu_optind+1 >= argc)
bu_exit(1, usage, argv[0]);
/* Open output file */
/* Open BRL-CAD database */
argc -= bu_optind;
argv += bu_optind;
if ((dbip = db_open(argv[0], DB_OPEN_READONLY)) == DBI_NULL) {
perror(argv[0]);
bu_exit(1, "ERROR: Unable to open geometry database file (%s)\n", argv[0]);
}
if (db_dirbuild(dbip))
bu_exit(1, "db_dirbuild failed\n");
BN_CK_TOL(tree_state.ts_tol);
RT_CK_TESS_TOL(tree_state.ts_ttol);
if (verbose) {
int i;
bu_log("Model: %s\n", argv[0]);
bu_log("Objects:");
for (i = 1; i < argc; i++)
bu_log(" %s", argv[i]);
bu_log("\nTessellation tolerances:\n\tabs = %g mm\n\trel = %g\n\tnorm = %g\n",
tree_state.ts_ttol->abs, tree_state.ts_ttol->rel, tree_state.ts_ttol->norm);
bu_log("Calculational tolerances:\n\tdist = %g mm perp = %g\n",
tree_state.ts_tol->dist, tree_state.ts_tol->perp);
}
/* Walk indicated tree(s). Each region will be output separately */
(void) db_walk_tree(dbip, argc-1, (const char **)(argv+1),
1, /* ncpu */
&tree_state,
0, /* take all regions */
do_region_end,
nmg_booltree_leaf_tess,
(void *)NULL); /* in librt/nmg_bool.c */
percent = 0;
if (regions_tried>0) {
percent = ((double)regions_converted * 100) / regions_tried;
bu_log("Tried %d regions, %d converted to NMG's successfully. %g%%\n",
regions_tried, regions_converted, percent);
}
percent = 0;
if (regions_tried > 0) {
percent = ((double)regions_written * 100) / regions_tried;
bu_log(" %d triangulated successfully. %g%%\n",
regions_written, percent);
}
bu_log("%zd triangles written\n", tot_polygons);
bu_log("Tessellation parameters used:\n");
bu_log(" abs [-a] %g\n", ttol.abs);
bu_log(" rel [-r] %g\n", ttol.rel);
bu_log(" norm [-n] %g\n", ttol.norm);
bu_log(" dist [-D] %g\n", tol.dist);
/* Release dynamic storage */
nmg_km(the_model);
rt_vlist_cleanup();
db_close(dbip);
return 0;
}
/*
* M A I N
*/
int
main(int argc, char **argv)
{
char *dot, *fig_file;
register int c;
double percent;
int size;
bu_setlinebuf( stderr );
jack_tree_state = rt_initial_tree_state; /* struct copy */
jack_tree_state.ts_tol = &tol;
jack_tree_state.ts_ttol = &ttol;
jack_tree_state.ts_m = &the_model;
ttol.magic = RT_TESS_TOL_MAGIC;
/* Defaults, updated by command line options. */
ttol.abs = 0.0;
ttol.rel = 0.01;
ttol.norm = 0.0;
/* XXX These need to be improved */
tol.magic = BN_TOL_MAGIC;
tol.dist = 0.005;
tol.dist_sq = tol.dist * tol.dist;
tol.perp = 1e-6;
tol.para = 1 - tol.perp;
rt_init_resource( &rt_uniresource, 0, NULL );
the_model = nmg_mm();
BU_LIST_INIT( &rt_g.rtg_vlfree ); /* for vlist macros */
/* Get command line arguments. */
while ((c = bu_getopt(argc, argv, "a:dn:p:r:vx:P:X:")) != EOF) {
switch (c) {
case 'a': /* Absolute tolerance. */
ttol.abs = atof(bu_optarg);
break;
case 'd':
debug_plots = 1;
break;
case 'n': /* Surface normal tolerance. */
ttol.norm = atof(bu_optarg);
break;
case 'p': /* Prefix for Jack file names. */
prefix = bu_optarg;
break;
case 'r': /* Relative tolerance. */
ttol.rel = atof(bu_optarg);
break;
case 'v':
verbose++;
break;
case 'P':
ncpu = atoi( bu_optarg );
rt_g.debug = 1; /* XXX DEBUG_ALLRAYS -- to get core dumps */
break;
case 'x':
sscanf( bu_optarg, "%x", (unsigned int *)&rt_g.debug );
break;
case 'X':
sscanf( bu_optarg, "%x", (unsigned int *)&rt_g.NMG_debug );
NMG_debug = rt_g.NMG_debug;
break;
default:
bu_exit(1, usage, argv[0]);
break;
}
}
if (bu_optind+1 >= argc) {
bu_exit(1, usage, argv[0]);
}
/* Open BRL-CAD database */
argc -= bu_optind;
argv += bu_optind;
if ((dbip = db_open(argv[0], "r")) == DBI_NULL) {
perror(argv[0]);
bu_exit(1, "ERROR: Unable to open geometry database (%s)\n", argv[0]);
}
if ( db_dirbuild( dbip ) ) {
bu_exit(1, "db_dirbuild failed\n" );
}
/* Create .fig file name and open it. */
size = sizeof(prefix) + sizeof(argv[0] + 4);
fig_file = bu_malloc(size, "st");
/* Ignore leading path name. */
if ((dot = strrchr(argv[0], '/')) != (char *)NULL) {
if (prefix) {
snprintf(fig_file, size, "%s%s", prefix, 1+dot);
} else {
snprintf(fig_file, size, "%s", 1+dot);
}
} else {
if (prefix)
snprintf(fig_file, size, "%s%s", prefix, argv[0]);
else
snprintf(fig_file, size, "%s", argv[0]);
}
/* Get rid of any file name extension (probably .g). */
if ((dot = strrchr(fig_file, '.')) != (char *)NULL)
*dot = '\0';
bu_strlcat(fig_file, ".fig", size); /* Add required Jack suffix. */
if ((fp_fig = fopen(fig_file, "wb")) == NULL)
perror(fig_file);
fprintf(fp_fig, "figure {\n");
bu_vls_init(&base_seg); /* .fig figure file's main segment. */
/* Walk indicated tree(s). Each region will be output separately */
(void)db_walk_tree(dbip, argc-1, (const char **)(argv+1),
1, /* ncpu */
&jack_tree_state,
0, /* take all regions */
do_region_end,
nmg_booltree_leaf_tess,
(genptr_t)NULL); /* in librt/nmg_bool.c */
fprintf(fp_fig, "\troot=%s_seg.base;\n", bu_vls_addr(&base_seg));
fprintf(fp_fig, "}\n");
fclose(fp_fig);
bu_free(fig_file, "st");
bu_vls_free(&base_seg);
percent = 0;
if (regions_tried>0) percent = ((double)regions_done * 100) / regions_tried;
printf("Tried %d regions, %d converted successfully. %g%%\n",
regions_tried, regions_done, percent);
return 0;
}
int
main(int argc, char **argv)
{
int c;
double percent;
int i;
bu_setprogname(argv[0]);
bu_setlinebuf(stderr);
RTG.debug = 0;
tree_state = rt_initial_tree_state; /* struct copy */
tree_state.ts_tol = &tol;
tree_state.ts_ttol = &ttol;
tree_state.ts_m = &the_model;
ttol.magic = RT_TESS_TOL_MAGIC;
/* Defaults, updated by command line options. */
ttol.abs = 0.0;
ttol.rel = 0.01;
ttol.norm = 0.0;
/* FIXME: These need to be improved */
tol.magic = BN_TOL_MAGIC;
tol.dist = BN_TOL_DIST;
tol.dist_sq = tol.dist * tol.dist;
tol.perp = 1e-6;
tol.para = 1 - tol.perp;
the_model = nmg_mm();
BU_LIST_INIT(&RTG.rtg_vlfree); /* for vlist macros */
/* Get command line arguments. */
while ((c = bu_getopt(argc, argv, "a:n:o:r:vx:D:P:X:e:ih?")) != -1) {
switch (c) {
case 'a': /* Absolute tolerance. */
ttol.abs = atof(bu_optarg);
ttol.rel = 0.0;
break;
case 'n': /* Surface normal tolerance. */
ttol.norm = atof(bu_optarg);
ttol.rel = 0.0;
break;
case 'o': /* Output file name. */
output_file = bu_optarg;
break;
case 'r': /* Relative tolerance. */
ttol.rel = atof(bu_optarg);
break;
case 'v':
verbose++;
break;
case 'P':
ncpu = atoi(bu_optarg);
break;
case 'x':
sscanf(bu_optarg, "%x", (unsigned int *)&RTG.debug);
break;
case 'D':
tol.dist = atof(bu_optarg);
tol.dist_sq = tol.dist * tol.dist;
rt_pr_tol(&tol);
break;
case 'X':
sscanf(bu_optarg, "%x", (unsigned int *)&RTG.NMG_debug);
NMG_debug = RTG.NMG_debug;
break;
case 'e': /* Error file name. */
error_file = bu_optarg;
break;
case 'i':
inches = 1;
break;
default:
usage(argv[0]);
}
}
if (bu_optind+1 >= argc)
usage(argv[0]);
if (!output_file) {
fp = stdout;
setmode(fileno(fp), O_BINARY);
} else {
/* Open output file */
if ((fp=fopen(output_file, "wb+")) == NULL) {
perror(argv[0]);
bu_exit(1, "Cannot open output file (%s) for writing\n", output_file);
}
}
/* Open g-acad error log file */
if (!error_file) {
fpe = stderr;
setmode(fileno(fpe), O_BINARY);
} else if ((fpe=fopen(error_file, "wb")) == NULL) {
perror(argv[0]);
bu_exit(1, "Cannot open output file (%s) for writing\n", error_file);
}
/* Open BRL-CAD database */
argc -= bu_optind;
argv += bu_optind;
if ((dbip = db_open(argv[0], DB_OPEN_READONLY)) == DBI_NULL) {
perror(argv[0]);
bu_exit(1, "Cannot open geometry database file (%s)\n", argv[0]);
}
if (db_dirbuild(dbip)) {
bu_exit(1, "db_dirbuild failed\n");
}
BN_CK_TOL(tree_state.ts_tol);
RT_CK_TESS_TOL(tree_state.ts_ttol);
fprintf(fpe, "Model: %s\n", argv[0]);
fprintf(fpe, "Objects:");
for (i=1; i<argc; i++)
fprintf(fpe, " %s", argv[i]);
fprintf(fpe, "\nTessellation tolerances:\n\tabs = %g mm\n\trel = %g\n\tnorm = %g\n",
tree_state.ts_ttol->abs, tree_state.ts_ttol->rel, tree_state.ts_ttol->norm);
fprintf(fpe, "Calculational tolerances:\n\tdist = %g mm perp = %g\n",
tree_state.ts_tol->dist, tree_state.ts_tol->perp);
bu_log("Model: %s\n", argv[0]);
bu_log("Objects:");
for (i=1; i<argc; i++)
bu_log(" %s", argv[i]);
bu_log("\nTessellation tolerances:\n\tabs = %g mm\n\trel = %g\n\tnorm = %g\n",
tree_state.ts_ttol->abs, tree_state.ts_ttol->rel, tree_state.ts_ttol->norm);
bu_log("Calculational tolerances:\n\tdist = %g mm perp = %g\n",
tree_state.ts_tol->dist, tree_state.ts_tol->perp);
/* Write out ACAD facet header */
if (inches)
fprintf(fp, "BRL-CAD generated ACAD FACET FILE (Units in)\n");
else
fprintf(fp, "BRL-CAD generated ACAD FACET FILE (Units mm)\n");
/* Generate space for number of facet entities, will write over later */
fprintf(fp, " ");
/* Walk indicated tree(s). Each region will be output separately */
(void) db_walk_tree(dbip, argc-1, (const char **)(argv+1),
1, /* ncpu */
&tree_state,
0, /* take all regions */
do_region_end,
nmg_booltree_leaf_tess,
(void *)NULL); /* in librt/nmg_bool.c */
percent = 0;
if (regions_tried>0) {
percent = ((double)regions_converted * 100) / regions_tried;
printf("Tried %d regions, %d converted to NMG's successfully. %g%%\n",
regions_tried, regions_converted, percent);
}
percent = 0;
if (regions_tried > 0) {
percent = ((double)regions_written * 100) / regions_tried;
printf(" %d triangulated successfully. %g%%\n",
regions_written, percent);
}
bu_log("%ld triangles written\n", tot_polygons);
fprintf(fpe, "%ld triangles written\n", tot_polygons);
/* Write out number of facet entities to .facet file */
rewind(fp);
bu_fseek(fp, 46, 0); /* Re-position pointer to 2nd line */
fprintf(fp, "%d\n", regions_written); /* Write out number of regions */
fclose(fp);
/* Release dynamic storage */
nmg_km(the_model);
rt_vlist_cleanup();
db_close(dbip);
return 0;
}
/**
* Called at the start of a run.
*
* Returns 1 if framebuffer should be opened, else 0.
*/
int
view_init(struct application *ap, char *file, char *UNUSED(obj), int minus_o, int minus_F)
{
/*
* Allocate a scanline for each processor.
*/
ap->a_hit = rayhit;
ap->a_miss = raymiss;
ap->a_onehit = 1;
/*
* Does the user want occlusion checking?
*
* If so, load and prep.
*/
if (bu_vls_strlen(&occlusion_objects) != 0) {
struct db_i *dbip;
int nObjs;
const char **objs;
int i;
bu_log("rtedge: loading occlusion geometry from %s.\n", file);
if (Tcl_SplitList(NULL, bu_vls_addr(&occlusion_objects), &nObjs,
&objs) == TCL_ERROR) {
bu_log("rtedge: occlusion list = %s\n",
bu_vls_addr(&occlusion_objects));
bu_exit(EXIT_FAILURE, "rtedge: could not parse occlusion objects list.\n");
}
for (i=0; i<nObjs; ++i) {
bu_log("rtedge: occlusion object %d = %s\n", i, objs[i]);
}
if ((dbip = db_open(file, DB_OPEN_READONLY)) == DBI_NULL)
bu_exit(EXIT_FAILURE, "rtedge: could not open geometry database file %s.\n", file);
RT_CK_DBI(dbip);
#if 0
/* FIXME: calling this when db_open()'s mapped file doesn't
* fail will cause duplicate directory entries. need to make
* sure db_dirbuild rebuilds from scratch or only updates
* existing entries when they exist.
*/
if (db_dirbuild(dbip) < 0)
bu_exit(EXIT_FAILURE, "rtedge: could not read database.\n");
#endif
occlusion_rtip = rt_new_rti(dbip); /* clones dbip */
for (i=0; i < MAX_PSW; i++) {
rt_init_resource(&occlusion_resources[i], i, occlusion_rtip);
bn_rand_init(occlusion_resources[i].re_randptr, i);
}
db_close(dbip); /* releases original dbip */
for (i=0; i<nObjs; ++i)
if (rt_gettree(occlusion_rtip, objs[i]) < 0)
bu_log("rtedge: gettree failed for %s\n", objs[i]);
else
bu_log("rtedge: got tree for object %d = %s\n", i, objs[i]);
bu_log("rtedge: occlusion rt_gettrees done.\n");
rt_prep(occlusion_rtip);
bu_log("rtedge: occlusion prep done.\n");
/*
* Create a set of application structures for the occlusion
* geometry. Need one per cpu, the upper half does the per-
* thread allocation in worker, but that's off limits.
*/
occlusion_apps = (struct application **)bu_calloc(npsw, sizeof(struct application *),
"occlusion application structure array");
for (i=0; i<npsw; ++i) {
BU_ALLOC(occlusion_apps[i], struct application);
RT_APPLICATION_INIT(occlusion_apps[i]);
occlusion_apps[i]->a_rt_i = occlusion_rtip;
occlusion_apps[i]->a_resource = (struct resource *)BU_PTBL_GET(&occlusion_rtip->rti_resources, i);
occlusion_apps[i]->a_onehit = 1;
occlusion_apps[i]->a_hit = occlusion_hit;
occlusion_apps[i]->a_miss = occlusion_miss;
if (rpt_overlap)
occlusion_apps[i]->a_logoverlap = (void (*)(struct application *, const struct partition *, const struct bu_ptbl *, const struct partition *))NULL;
else
occlusion_apps[i]->a_logoverlap = rt_silent_logoverlap;
}
bu_log("rtedge: will perform occlusion testing.\n");
/*
* If an inclusion mode has not been specified, use the default.
*/
if (occlusion_mode == OCCLUSION_MODE_NONE) {
occlusion_mode = OCCLUSION_MODE_DEFAULT;
bu_log("rtedge: occlusion mode = %d\n", occlusion_mode);
}
if ((occlusion_mode != OCCLUSION_MODE_NONE) &&
(overlay == OVERLAY_MODE_UNSET)) {
bu_log("rtedge: automagically activating overlay mode.\n");
overlay = OVERLAY_MODE_DOIT;
}
}
if (occlusion_mode != OCCLUSION_MODE_NONE &&
bu_vls_strlen(&occlusion_objects) == 0) {
bu_exit(EXIT_FAILURE, "rtedge: occlusion mode set, but no objects were specified.\n");
}
/* if non-default/inverted background was requested, swap the
* foreground and background colors.
*/
if (!default_background) {
color tmp;
tmp[RED] = fgcolor[RED];
tmp[GRN] = fgcolor[GRN];
tmp[BLU] = fgcolor[BLU];
fgcolor[RED] = bgcolor[RED];
fgcolor[GRN] = bgcolor[GRN];
fgcolor[BLU] = bgcolor[BLU];
bgcolor[RED] = tmp[RED];
bgcolor[GRN] = tmp[GRN];
bgcolor[BLU] = tmp[BLU];
}
if (minus_o && (overlay || blend)) {
/*
* Output is to a file stream. Do not allow parallel
* processing since we can't seek to the rows.
*/
RTG.rtg_parallel = 0;
bu_log("view_init: deactivating parallelism due to -o option.\n");
/*
* The overlay and blend cannot be used in -o mode. Note that
* the overlay directive takes precedence, they can't be used
* together.
*/
overlay = 0;
blend = 0;
bu_log("view_init: deactivating overlay and blending due to -o option.\n");
}
if (overlay)
bu_log("view_init: will perform simple overlay.\n");
else if (blend)
bu_log("view_init: will perform blending.\n");
return minus_F || (!minus_o && !minus_F); /* we need a framebuffer */
}
int
main(int argc, char *argv[])
{
struct db_i *dbip;
struct directory *dp;
struct rt_db_internal intern;
struct rt_bot_internal *bot_ip = NULL;
struct rt_wdb *wdbp;
struct bu_vls name;
struct bu_vls bname;
struct Mesh_Info *prev_mesh = NULL;
struct Mesh_Info *mesh = NULL;
bu_vls_init(&name);
if (argc != 3) {
bu_exit(1, "Usage: %s file.g object", argv[0]);
}
dbip = db_open(argv[1], DB_OPEN_READWRITE);
if (dbip == DBI_NULL) {
bu_exit(1, "ERROR: Unable to read from geometry database file %s\n", argv[1]);
}
if (db_dirbuild(dbip) < 0)
bu_exit(1, "ERROR: Unable to read from %s\n", argv[1]);
dp = db_lookup(dbip, argv[2], LOOKUP_QUIET);
if (dp == RT_DIR_NULL) {
bu_exit(1, "ERROR: Unable to look up object %s\n", argv[2]);
}
RT_DB_INTERNAL_INIT(&intern)
if (rt_db_get_internal(&intern, dp, dbip, NULL, &rt_uniresource) < 0) {
bu_exit(1, "ERROR: Unable to get internal representation of %s\n", argv[2]);
}
if (intern.idb_minor_type != DB5_MINORTYPE_BRLCAD_BOT) {
bu_exit(1, "ERROR: object %s does not appear to be of type BoT\n", argv[2]);
} else {
bot_ip = (struct rt_bot_internal *)intern.idb_ptr;
}
RT_BOT_CK_MAGIC(bot_ip);
for (size_t i_cnt = 1; i_cnt < 3; i_cnt++) {
mesh = iterate(bot_ip, prev_mesh);
prev_mesh = mesh;
// Plot results
struct bu_vls fname;
bu_vls_init(&fname);
bu_vls_printf(&fname, "root3_%d.pl", i_cnt);
FILE* plot_file = fopen(bu_vls_addr(&fname), "w");
std::map<size_t, std::vector<size_t> >::iterator f_it;
std::vector<size_t>::iterator l_it;
int r = int(256*drand48() + 1.0);
int g = int(256*drand48() + 1.0);
int b = int(256*drand48() + 1.0);
for (f_it = mesh->face_pts.begin(); f_it != mesh->face_pts.end(); f_it++) {
l_it = (*f_it).second.begin();
plot_face(&mesh->points_p0[(int)(*l_it)], &mesh->points_p0[(int)(*(l_it+1))], &mesh->points_p0[(int)(*(l_it+2))], r, g , b, plot_file);
}
fclose(plot_file);
}
// When constructing the final BoT, use the limit points for all
// vertices
ON_3dPointArray points_inf;
for (size_t v = 0; v < (size_t)mesh->points_p0.Count(); v++) {
points_inf.Append(*mesh->points_p0.At((int)v));
//point_inf(v, mesh, &points_inf);
}
// The subdivision process shrinks the bot relative to its original
// vertex positions - to better approximate the original surface,
// average the change in position of the original vertices to get a
// scaling factor and apply it to all points in the final mesh.
fastf_t scale = 0.0;
for (size_t pcnt = 0; pcnt < bot_ip->num_vertices; pcnt++) {
ON_3dVector v1(ON_3dPoint(&bot_ip->vertices[pcnt*3]));
ON_3dVector v2(*points_inf.At((int)pcnt));
scale += 1 + (v1.Length() - v2.Length())/v1.Length();
}
scale = scale / bot_ip->num_vertices;
for (size_t pcnt = 0; pcnt < (size_t)points_inf.Count(); pcnt++) {
ON_3dPoint p0(*points_inf.At((int)pcnt));
ON_3dPoint p1 = p0 * scale;
*points_inf.At((int)pcnt) = p1;
}
wdbp = wdb_dbopen(dbip, RT_WDB_TYPE_DB_DISK);
fastf_t *vertices = (fastf_t *)bu_malloc(sizeof(fastf_t) * points_inf.Count() * 3, "new verts");
int *faces = (int *)bu_malloc(sizeof(int) * mesh->face_pts.size() * 3, "new faces");
for (size_t v = 0; v < (size_t)points_inf.Count(); v++) {
vertices[v*3] = points_inf[(int)v].x;
vertices[v*3+1] = points_inf[(int)v].y;
vertices[v*3+2] = points_inf[(int)v].z;
}
std::map<size_t, std::vector<size_t> >::iterator f_it;
std::vector<size_t>::iterator l_it;
for (f_it = mesh->face_pts.begin(); f_it != mesh->face_pts.end(); f_it++) {
l_it = (*f_it).second.begin();
faces[(*f_it).first*3] = (*l_it);
faces[(*f_it).first*3+1] = (*(l_it + 1));
faces[(*f_it).first*3+2] = (*(l_it + 2));
}
bu_vls_init(&bname);
bu_vls_sprintf(&bname, "%s_subd", argv[2]);
mk_bot(wdbp, bu_vls_addr(&bname), RT_BOT_SOLID, RT_BOT_UNORIENTED, 0, points_inf.Count(), mesh->face_pts.size(), vertices, faces, (fastf_t *)NULL, (struct bu_bitv *)NULL);
wdb_close(wdbp);
bu_vls_free(&bname);
bu_free(vertices, "free subdivision BoT vertices");
bu_free(faces, "free subdivision BoT faces");
return 0;
}
int
ged_keep(struct ged *gedp, int argc, const char *argv[])
{
int i;
struct keep_node_data knd;
struct rt_wdb *keepfp;
struct directory *dp;
struct bu_vls title = BU_VLS_INIT_ZERO;
struct db_i *new_dbip;
const char *cmd = argv[0];
static const char *usage = "[-R] file object(s)";
int c;
int flag_R = 0;
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* must be wanting help */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", cmd, usage);
return GED_HELP;
}
/* check for options */
bu_optind = 1;
while ((c = bu_getopt(argc, (char * const *)argv, "R")) != -1) {
switch (c) {
case 'R':
/* not recursively */
flag_R = 1;
break;
default:
bu_vls_printf(gedp->ged_result_str, "Unrecognized option - %c", c);
return GED_ERROR;
}
}
/* skip options processed plus command name */
argc -= bu_optind;
argv += bu_optind;
if (argc < 2) {
bu_vls_printf(gedp->ged_result_str, "ERROR: missing file or object names\n");
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", cmd, usage);
return GED_ERROR;
}
/* First, clear any existing counts */
for (i = 0; i < RT_DBNHASH; i++) {
for (dp = gedp->ged_wdbp->dbip->dbi_Head[i]; dp != RT_DIR_NULL; dp = dp->d_forw)
dp->d_nref = 0;
}
/* Alert user if named file already exists */
new_dbip = db_open(argv[0], DB_OPEN_READWRITE);
if (new_dbip != DBI_NULL) {
if (db_version(new_dbip) != db_version(gedp->ged_wdbp->dbip)) {
bu_vls_printf(gedp->ged_result_str, "%s: File format mismatch between '%s' and '%s'\n",
cmd, argv[0], gedp->ged_wdbp->dbip->dbi_filename);
return GED_ERROR;
}
if ((keepfp = wdb_dbopen(new_dbip, RT_WDB_TYPE_DB_DISK)) == NULL) {
bu_vls_printf(gedp->ged_result_str, "%s: Error opening '%s'\n", cmd, argv[0]);
return GED_ERROR;
} else {
bu_vls_printf(gedp->ged_result_str, "%s: Appending to '%s'\n", cmd, argv[0]);
/* --- Scan geometry database and build in-memory directory --- */
db_dirbuild(new_dbip);
}
} else {
/* Create a new database */
keepfp = wdb_fopen_v(argv[0], db_version(gedp->ged_wdbp->dbip));
if (keepfp == NULL) {
perror(argv[0]);
return GED_ERROR;
}
}
knd.wdbp = keepfp;
knd.gedp = gedp;
/* ident record */
if (bu_strncmp(gedp->ged_wdbp->dbip->dbi_title, "Parts of: ", 10) != 0) {
bu_vls_strcat(&title, "Parts of: ");
}
bu_vls_strcat(&title, gedp->ged_wdbp->dbip->dbi_title);
if (db_update_ident(keepfp->dbip, bu_vls_addr(&title), gedp->ged_wdbp->dbip->dbi_local2base) < 0) {
perror("fwrite");
bu_vls_printf(gedp->ged_result_str, "db_update_ident() failed\n");
wdb_close(keepfp);
bu_vls_free(&title);
return GED_ERROR;
}
bu_vls_free(&title);
for (i = 1; i < argc; i++) {
if ((dp = db_lookup(gedp->ged_wdbp->dbip, argv[i], LOOKUP_NOISY)) == RT_DIR_NULL)
continue;
if (!flag_R) {
/* recursively keep objects */
db_functree(gedp->ged_wdbp->dbip, dp, node_write, node_write, &rt_uniresource, (void *)&knd);
} else {
/* keep just this object */
node_write(gedp->ged_wdbp->dbip, dp, (void *)&knd);
}
}
wdb_close(keepfp);
return GED_OK;
}
int
main(int argc, char **argv)
{
int i, j;
int c;
double percent;
bu_setprogname(argv[0]);
bu_setlinebuf(stderr);
RTG.debug = 0;
ttol.magic = RT_TESS_TOL_MAGIC;
/* Defaults, updated by command line options. */
ttol.abs = 0.0;
ttol.rel = 0.01;
ttol.norm = 0.0;
/* FIXME: These need to be improved */
tol.magic = BN_TOL_MAGIC;
tol.dist = 0.0005;
tol.dist_sq = tol.dist * tol.dist;
tol.perp = 1e-6;
tol.para = 1 - tol.perp;
the_model = (struct model *)NULL;
tree_state = rt_initial_tree_state; /* struct copy */
tree_state.ts_m = &the_model;
tree_state.ts_tol = &tol;
tree_state.ts_ttol = &ttol;
rt_init_resource(&rt_uniresource, 0, NULL);
/* For visualization purposes, in the debug plot files */
{
/* WTF: This value is specific to the Bradley */
nmg_eue_dist = 2.0;
}
BU_LIST_INIT(&RTG.rtg_vlfree); /* for vlist macros */
/* Get command line arguments. */
while ((c = bu_getopt(argc, argv, "a:n:o:r:vx:P:X:h?")) != -1) {
switch (c) {
case 'a': /* Absolute tolerance. */
ttol.abs = atof(bu_optarg);
ttol.rel = 0.0;
break;
case 'n': /* Surface normal tolerance. */
ttol.norm = atof(bu_optarg);
ttol.rel = 0.0;
break;
case 'o': /* Output file name */
out_file = bu_optarg;
break;
case 'r': /* Relative tolerance. */
ttol.rel = atof(bu_optarg);
break;
case 'v':
verbose++;
break;
case 'P':
ncpu = atoi(bu_optarg);
break;
case 'x':
sscanf(bu_optarg, "%x", (unsigned int *)&RTG.debug);
break;
case 'X':
sscanf(bu_optarg, "%x", (unsigned int *)&RTG.NMG_debug);
NMG_debug = RTG.NMG_debug;
break;
default:
usage(argv[0]);
}
}
if (bu_optind+1 >= argc)
usage(argv[0]);
/* Open BRL-CAD database */
if ((dbip = db_open(argv[bu_optind], DB_OPEN_READONLY)) == DBI_NULL) {
perror(argv[0]);
bu_exit(1, "Cannot open geometry database file %s\n", argv[bu_optind]);
}
if (db_dirbuild(dbip)) {
bu_exit(1, "db_dirbuild failed\n");
}
if (out_file == NULL) {
fp_out = stdout;
setmode(fileno(fp_out), O_BINARY);
} else {
if ((fp_out = fopen(out_file, "wb")) == NULL) {
bu_log("Cannot open %s\n", out_file);
perror(argv[0]);
return 2;
}
}
bu_optind++;
fprintf(fp_out, "$03");
/* First produce an unordered list of region ident codes */
(void)db_walk_tree(dbip, argc-bu_optind, (const char **)(&argv[bu_optind]),
1, /* ncpu */
&tree_state,
get_reg_id, /* put id in table */
region_stub,
leaf_stub,
(void *)NULL);
/* Process regions in ident order */
curr_id = 0;
for (i = 0; i < ident_length; i++) {
int next_id = 99999999;
for (j = 0; j < ident_length; j++) {
int test_id;
test_id = idents[j];
if (test_id > curr_id && test_id < next_id)
next_id = test_id;
}
curr_id = next_id;
face_count = 0;
bu_log("Processing id %d\n", curr_id);
/* Walk indicated tree(s). Each region will be output separately */
tree_state = rt_initial_tree_state; /* struct copy */
the_model = nmg_mm();
tree_state.ts_m = &the_model;
tree_state.ts_tol = &tol;
tree_state.ts_ttol = &ttol;
(void)db_walk_tree(dbip, argc-bu_optind, (const char **)(&argv[bu_optind]),
ncpu,
&tree_state,
select_region,
do_region_end,
nmg_booltree_leaf_tess,
(void *)NULL); /* in librt/nmg_bool.c */
nmg_km(the_model);
}
percent = 0;
if (regions_tried > 0)
percent = ((double)regions_converted * 100) / regions_tried;
printf("Tried %d regions, %d converted successfully. %g%%\n",
regions_tried, regions_converted, percent);
percent = 0;
if (regions_tried > 0)
percent = ((double)regions_written * 100) / regions_tried;
printf(" %d written successfully. %g%%\n",
regions_written, percent);
/* Release dynamic storage */
rt_vlist_cleanup();
db_close(dbip);
return 0;
}
int
main(int argc, char **argv)
{
int i;
int c;
struct plate_mode pm;
bu_setprogname(argv[0]);
bu_setlinebuf( stderr );
the_model = nmg_mm();
tree_state = rt_initial_tree_state; /* struct copy */
tree_state.ts_tol = &tol;
tree_state.ts_ttol = &ttol;
tree_state.ts_m = &the_model;
ttol.magic = RT_TESS_TOL_MAGIC;
/* Defaults, updated by command line options. */
ttol.abs = 0.0;
ttol.rel = 0.01;
ttol.norm = 0.0;
/* FIXME: These need to be improved */
tol.magic = BN_TOL_MAGIC;
tol.dist = BN_TOL_DIST;
tol.dist_sq = tol.dist * tol.dist;
tol.perp = 1e-6;
tol.para = 1 - tol.perp;
/* NOTE: For visualization purposes, in the debug plot files */
{
/* WTF: This value is specific to the Bradley */
nmg_eue_dist = 2.0;
}
BU_LIST_INIT( &RTG.rtg_vlfree ); /* for vlist macros */
BARRIER_CHECK;
/* Get command line arguments. */
while ((c = bu_getopt(argc, argv, "d:a:n:o:r:vx:P:X:u:h?")) != -1) {
switch (c) {
case 'a': /* Absolute tolerance. */
ttol.abs = atof(bu_optarg);
ttol.rel = 0.0;
break;
case 'd': /* calculational tolerance */
tol.dist = atof( bu_optarg );
tol.dist_sq = tol.dist * tol.dist;
break;
case 'n': /* Surface normal tolerance. */
ttol.norm = atof(bu_optarg)*DEG2RAD;
ttol.rel = 0.0;
break;
case 'o': /* Output file name */
out_file = bu_optarg;
break;
case 'r': /* Relative tolerance. */
ttol.rel = atof(bu_optarg);
break;
case 'v':
verbose++;
break;
case 'P':
ncpu = atoi(bu_optarg);
break;
case 'x':
sscanf( bu_optarg, "%x", (unsigned int *)&RTG.debug );
break;
case 'X':
sscanf( bu_optarg, "%x", (unsigned int *)&RTG.NMG_debug );
NMG_debug = RTG.NMG_debug;
break;
case 'u':
units = bu_strdup( bu_optarg );
scale_factor = bu_units_conversion( units );
if ( ZERO(scale_factor) )
bu_exit(1, "Unrecognized units (%s)\n", units );
scale_factor = 1.0 / scale_factor;
break;
default:
print_usage(argv[0]);
}
}
if (bu_optind+1 >= argc)
print_usage(argv[0]);
/* Open BRL-CAD database */
if ((dbip = db_open( argv[bu_optind], DB_OPEN_READONLY)) == DBI_NULL)
{
perror(argv[0]);
bu_exit(1, "Cannot open geometry database file %s\n", argv[bu_optind] );
}
if ( db_dirbuild( dbip ) )
bu_exit(1, "db_dirbuild() failed!\n" );
if (out_file == NULL) {
outfp = stdout;
setmode(fileno(outfp), O_BINARY);
} else {
if ((outfp = fopen( out_file, "wb")) == NULL)
{
perror( argv[0] );
bu_exit(2, "Cannot open %s\n", out_file );
}
}
writeX3dHeader(outfp, out_file);
bu_optind++;
BARRIER_CHECK;
pm.num_bots = 0;
pm.num_nonbots = 0;
pm.array_size = 5;
pm.bots = (struct rt_bot_internal **)bu_calloc( pm.array_size,
sizeof( struct rt_bot_internal *), "pm.bots" );
for ( i=bu_optind; i<argc; i++ )
{
struct directory *dp;
dp = db_lookup( dbip, argv[i], LOOKUP_QUIET );
if ( dp == RT_DIR_NULL )
{
bu_log( "Cannot find %s\n", argv[i] );
continue;
}
/* light source must be a combination */
if ( !(dp->d_flags & RT_DIR_COMB) )
continue;
/* walk trees selecting only light source regions */
(void)db_walk_tree(dbip, 1, (const char **)(&argv[i]),
ncpu,
&tree_state,
select_lights,
do_region_end,
leaf_tess,
(void *)&pm); /* in librt/nmg_bool.c */
}
BARRIER_CHECK;
/* Walk indicated tree(s). Each non-light-source region will be output separately */
(void)db_walk_tree(dbip, argc-bu_optind, (const char **)(&argv[bu_optind]),
ncpu,
&tree_state,
select_non_lights,
do_region_end,
leaf_tess,
(void *)&pm); /* in librt/nmg_bool.c */
BARRIER_CHECK;
/* Release dynamic storage */
nmg_km(the_model);
db_close(dbip);
/* Now we need to close each group set */
writeX3dEnd(outfp);
if ( verbose )
bu_log( "Total of %d regions converted of %d regions attempted\n",
regions_converted, regions_tried );
return 0;
}
/**
* This is the gist for what is going on (not verified):
*
* 1. initialize tree_state (db_tree_state)
* 2. Deal with command line arguments. Strip off everything but regions for processing.
* 3. Open geometry (.g) file and build directory db_dirbuild
* 4. db_walk_tree (get_layer) for layer names only
* 5. Initialize tree_state
* 6. Initialize model (nmg)\
* 7. db_walk_tree (gcv_region_end)
* 8. Cleanup
*/
int
main(int argc, char *argv[])
{
int c;
double percent;
bu_setlinebuf(stderr);
tree_state = rt_initial_tree_state; /* struct copy */
tree_state.ts_tol = &tol;
tree_state.ts_ttol = &ttol;
tree_state.ts_m = &the_model;
/* Set up tessellation tolerance defaults */
ttol.magic = RT_TESS_TOL_MAGIC;
/* Defaults, updated by command line options. */
ttol.abs = 0.0;
ttol.rel = 0.01;
ttol.norm = 0.0;
/* Set up calculation tolerance defaults */
/* FIXME: These need to be improved */
tol.magic = BN_TOL_MAGIC;
tol.dist = 0.0005;
tol.dist_sq = tol.dist * tol.dist;
tol.perp = 1e-6;
tol.para = 1 - tol.perp;
/* init resources we might need */
rt_init_resource(&rt_uniresource, 0, NULL);
BU_LIST_INIT(&RTG.rtg_vlfree); /* for vlist macros */
/* Get command line arguments. */
while ((c = bu_getopt(argc, argv, "a:n:o:pr:vx:D:P:X:ih?")) != -1) {
switch (c) {
case 'a': /* Absolute tolerance. */
ttol.abs = atof(bu_optarg);
ttol.rel = 0.0;
break;
case 'n': /* Surface normal tolerance. */
ttol.norm = atof(bu_optarg);
ttol.rel = 0.0;
break;
case 'o': /* Output file name. */
output_file = bu_optarg;
break;
case 'p':
polyface_mesh = 1;
break;
case 'r': /* Relative tolerance. */
ttol.rel = atof(bu_optarg);
break;
case 'v':
verbose++;
break;
case 'P':
ncpu = atoi(bu_optarg);
break;
case 'x':
sscanf(bu_optarg, "%x", (unsigned int *)&RTG.debug);
break;
case 'D':
tol.dist = atof(bu_optarg);
tol.dist_sq = tol.dist * tol.dist;
rt_pr_tol(&tol);
break;
case 'X':
sscanf(bu_optarg, "%x", (unsigned int *)&RTG.NMG_debug);
NMG_debug = RTG.NMG_debug;
break;
case 'i':
inches = 1;
break;
default:
usage(argv[0]);
bu_exit(1, "%s\n", brlcad_ident("BRL-CAD to DXF Exporter"));
break;
}
}
if (bu_optind+1 >= argc) {
usage(argv[0]);
bu_exit(1, "%s\n", brlcad_ident("BRL-CAD to DXF Exporter"));
}
if (!output_file) {
fp = stdout;
setmode(fileno(fp), O_BINARY);
} else {
/* Open output file */
if ((fp=fopen(output_file, "w+b")) == NULL) {
perror(argv[0]);
bu_exit(1, " Cannot open output file (%s) for writing\n", output_file);
}
}
/* Open BRL-CAD database */
argc -= bu_optind;
argv += bu_optind;
if ((dbip = db_open(argv[0], DB_OPEN_READONLY)) == DBI_NULL) {
perror(argv[0]);
bu_exit(1, "Unable to open geometry database file (%s)\n", argv[0]);
}
if (db_dirbuild(dbip)) {
bu_exit(1, "db_dirbuild failed\n");
}
BN_CK_TOL(tree_state.ts_tol);
RT_CK_TESS_TOL(tree_state.ts_ttol);
if (verbose) {
int i;
bu_log("Model: %s\n", argv[0]);
bu_log("Objects:");
for (i = 1; i < argc; i++)
bu_log(" %s", argv[i]);
bu_log("\nTessellation tolerances:\n\tabs = %g mm\n\trel = %g\n\tnorm = %g\n",
tree_state.ts_ttol->abs, tree_state.ts_ttol->rel, tree_state.ts_ttol->norm);
bu_log("Calculational tolerances:\n\tdist = %g mm perp = %g\n",
tree_state.ts_tol->dist, tree_state.ts_tol->perp);
}
/* output DXF header and start of TABLES section */
fprintf(fp,
"0\nSECTION\n2\nHEADER\n999\n%s\n0\nENDSEC\n0\nSECTION\n2\nTABLES\n0\nTABLE\n2\nLAYER\n",
argv[argc-1]);
/* Walk indicated tree(s) just for layer names to put in TABLES section */
(void)db_walk_tree(dbip, argc-1, (const char **)(argv+1),
1, /* ncpu */
&tree_state,
0, /* take all regions */
get_layer,
NULL,
(void *)NULL); /* in librt/nmg_bool.c */
/* end of layers section, start of ENTITIES SECTION */
fprintf(fp, "0\nENDTAB\n0\nENDSEC\n0\nSECTION\n2\nENTITIES\n");
/* Walk indicated tree(s). Each region will be output separately */
tree_state = rt_initial_tree_state; /* struct copy */
tree_state.ts_tol = &tol;
tree_state.ts_ttol = &ttol;
/* make empty NMG model */
the_model = nmg_mm();
tree_state.ts_m = &the_model;
(void) db_walk_tree(dbip, argc-1, (const char **)(argv+1),
1, /* ncpu */
&tree_state,
0, /* take all regions */
gcv_region_end,
nmg_booltree_leaf_tess,
(void *)&gcvwriter); /* callback for gcv_region_end */
percent = 0;
if (regions_tried>0) {
percent = ((double)regions_converted * 100) / regions_tried;
if (verbose)
bu_log("Tried %d regions, %d converted to NMG's successfully. %g%%\n",
regions_tried, regions_converted, percent);
}
percent = 0;
if (regions_tried > 0) {
percent = ((double)regions_written * 100) / regions_tried;
if (verbose)
bu_log(" %d triangulated successfully. %g%%\n",
regions_written, percent);
}
bu_log("%ld triangles written\n", (long int)tot_polygons);
fprintf(fp, "0\nENDSEC\n0\nEOF\n");
if (output_file) {
fclose(fp);
}
/* Release dynamic storage */
nmg_km(the_model);
rt_vlist_cleanup();
db_close(dbip);
return 0;
}
