/** * 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; }