int rt_db_get_internal( struct rt_db_internal *ip, const struct directory *dp, const struct db_i *dbip, const mat_t mat, struct resource *resp) { struct bu_external ext; int id; int ret; RT_DB_INTERNAL_INIT(ip); if (dbip->dbi_version > 4) return rt_db_get_internal5(ip, dp, dbip, mat, resp); BU_EXTERNAL_INIT(&ext); if (db_get_external(&ext, dp, dbip) < 0) return -2; /* FAIL */ if (dp->d_flags & RT_DIR_COMB) { id = ID_COMBINATION; } else { /* As a convenience to older ft_import4 routines */ if (mat == NULL) mat = bn_mat_identity; id = rt_id_solid(&ext); } /* ip is already initialized and should not be re-initialized */ ret = -1; if (OBJ[id].ft_import4) { ret = OBJ[id].ft_import4(ip, &ext, mat, dbip, resp); } if (ret < 0) { bu_log("rt_db_get_internal(%s): import failure\n", dp->d_namep); rt_db_free_internal(ip); bu_free_external(&ext); return -1; /* FAIL */ } bu_free_external(&ext); RT_CK_DB_INTERNAL(ip); ip->idb_meth = &OBJ[id]; /* prior to version 5, there are no attributes ... */ bu_avs_init_empty(&ip->idb_avs); /* ... but this isn't the whole story: */ if (id == ID_COMBINATION) { const struct rt_comb_internal *comb = (const struct rt_comb_internal *)ip->idb_ptr; RT_CK_COMB(comb); db5_sync_comb_to_attr(&ip->idb_avs, comb); } return id; /* OK */ }
/* * Process pixels from 'a' to 'b' inclusive. * The results are sent back all at once. * Limitation: may not do more than 'width' pixels at once, * because that is the size of the buffer (for now). */ void ph_lines(struct pkg_conn *UNUSED(pc), char *buf) { int a, b, fr; struct line_info info; struct rt_i *rtip = APP.a_rt_i; struct bu_external ext; RT_CK_RTI(rtip); if (debug > 1) fprintf(stderr, "ph_lines: %s\n", buf); if (!seen_gettrees) { bu_log("ph_lines: no MSG_GETTREES yet\n"); return; } if (!seen_matrix) { bu_log("ph_lines: no MSG_MATRIX yet\n"); return; } a=0; b=0; fr=0; if (sscanf(buf, "%d %d %d", &a, &b, &fr) != 3) bu_exit(2, "ph_lines: %s conversion error\n", buf); srv_startpix = a; /* buffer un-offset for view_pixel */ if (b-a+1 > srv_scanlen) b = a + srv_scanlen - 1; rtip->rti_nrays = 0; info.li_startpix = a; info.li_endpix = b; info.li_frame = fr; rt_prep_timer(); do_run(a, b); info.li_nrays = rtip->rti_nrays; info.li_cpusec = rt_read_timer((char *)0, 0); info.li_percent = 42.0; /* for now */ if (!bu_struct_export(&ext, (void *)&info, desc_line_info)) bu_exit(98, "ph_lines: bu_struct_export failure\n"); if (debug) { fprintf(stderr, "PIXELS fr=%d pix=%d..%d, rays=%d, cpu=%g\n", info.li_frame, info.li_startpix, info.li_endpix, info.li_nrays, info.li_cpusec); } if (pkg_2send(MSG_PIXELS, (const char *)ext.ext_buf, ext.ext_nbytes, (const char *)scanbuf, (b-a+1)*3, pcsrv) < 0) { fprintf(stderr, "MSG_PIXELS send error\n"); bu_free_external(&ext); } bu_free_external(&ext); }
int ged_copy(struct ged *gedp, int argc, const char *argv[]) { struct directory *from_dp; struct bu_external external; static const char *usage = "from to"; 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); /* must be wanting help */ if (argc == 1) { bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage); return GED_HELP; } if (argc != 3) { bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage); return GED_ERROR; } GED_DB_LOOKUP(gedp, from_dp, argv[1], LOOKUP_NOISY, GED_ERROR & GED_QUIET); GED_CHECK_EXISTS(gedp, argv[2], LOOKUP_QUIET, GED_ERROR); if (db_get_external(&external, from_dp, gedp->ged_wdbp->dbip)) { bu_vls_printf(gedp->ged_result_str, "Database read error, aborting\n"); return GED_ERROR; } if (wdb_export_external(gedp->ged_wdbp, &external, argv[2], from_dp->d_flags, from_dp->d_minor_type) < 0) { bu_free_external(&external); bu_vls_printf(gedp->ged_result_str, "Failed to write new object (%s) to database - aborting!!\n", argv[2]); return GED_ERROR; } bu_free_external(&external); return GED_OK; }
int rt_db_put_internal( struct directory *dp, struct db_i *dbip, struct rt_db_internal *ip, struct resource *resp) { struct bu_external ext; int ret; RT_CK_DB_INTERNAL(ip); if (db_version(dbip) > 4) return rt_db_put_internal5(dp, dbip, ip, resp, DB5_MAJORTYPE_BRLCAD); BU_EXTERNAL_INIT(&ext); /* Scale change on export is 1.0 -- no change */ ret = -1; if (ip->idb_meth->ft_export4) { ret = ip->idb_meth->ft_export4(&ext, ip, 1.0, dbip, resp); } if (ret < 0) { bu_log("rt_db_put_internal(%s): solid export failure\n", dp->d_namep); rt_db_free_internal(ip); bu_free_external(&ext); return -2; /* FAIL */ } rt_db_free_internal(ip); if (db_put_external(&ext, dp, dbip) < 0) { bu_free_external(&ext); return -1; /* FAIL */ } bu_free_external(&ext); return 0; /* OK */ }
int rt_fwrite_internal( FILE *fp, const char *name, const struct rt_db_internal *ip, double conv2mm) { struct bu_external ext; int ret; RT_CK_DB_INTERNAL(ip); RT_CK_FUNCTAB(ip->idb_meth); BU_EXTERNAL_INIT(&ext); ret = -1; if (ip->idb_meth->ft_export4) { ret = ip->idb_meth->ft_export4(&ext, ip, conv2mm, NULL /*dbip*/, &rt_uniresource); } if (ret < 0) { bu_log("rt_file_put_internal(%s): solid export failure\n", name); bu_free_external(&ext); return -2; /* FAIL */ } BU_CK_EXTERNAL(&ext); if (db_fwrite_external(fp, name, &ext) < 0) { bu_log("rt_fwrite_internal(%s): db_fwrite_external() error\n", name); bu_free_external(&ext); return -3; } bu_free_external(&ext); return 0; }
int db_dump(struct rt_wdb *wdbp, struct db_i *dbip) /* output */ /* input */ { register int i; register struct directory *dp; struct bu_external ext; RT_CK_DBI(dbip); RT_CK_WDB(wdbp); /* just in case since we don't actually handle it below */ if (db_version(dbip) != db_version(wdbp->dbip)) { bu_log("Internal Error: dumping a v%d database into a v%d database is untested\n", db_version(dbip), db_version(wdbp->dbip)); return -1; } /* Output all directory entries */ for (i = 0; i < RT_DBNHASH; i++) { for (dp = dbip->dbi_Head[i]; dp != RT_DIR_NULL; dp = dp->d_forw) { RT_CK_DIR(dp); /* XXX Need to go to internal form, if database versions don't match */ if (db_get_external(&ext, dp, dbip) < 0) { bu_log("db_dump() read failed on %s, skipping\n", dp->d_namep); continue; } if (wdb_export_external(wdbp, &ext, dp->d_namep, dp->d_flags & ~(RT_DIR_INMEM), dp->d_minor_type) < 0) { bu_log("db_dump() write failed on %s, aborting\n", dp->d_namep); bu_free_external(&ext); return -1; } bu_free_external(&ext); } } return 0; }
int ged_unhide(struct ged *gedp, int argc, const char *argv[]) { struct directory *dp; struct db_i *dbip; struct bu_external ext; struct bu_external tmp; struct db5_raw_internal raw; int i; static const char *usage = "object(s)"; 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); /* must be wanting help */ if (argc == 1) { bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage); return GED_HELP; } dbip = gedp->ged_wdbp->dbip; if (db_version(dbip) < 5) { bu_vls_printf(gedp->ged_result_str, "Database was created with a previous release of BRL-CAD.\nSelect \"Tools->Upgrade Database...\" to enable support for this feature."); return GED_ERROR; } for (i = 1; i < argc; i++) { if ((dp = db_lookup(dbip, argv[i], LOOKUP_NOISY)) == RT_DIR_NULL) { continue; } RT_CK_DIR(dp); BU_EXTERNAL_INIT(&ext); if (db_get_external(&ext, dp, dbip) < 0) { bu_vls_printf(gedp->ged_result_str, "db_get_external failed for %s\n", dp->d_namep); continue; } if (db5_get_raw_internal_ptr(&raw, ext.ext_buf) == NULL) { bu_vls_printf(gedp->ged_result_str, "db5_get_raw_internal_ptr() failed for %s\n", dp->d_namep); bu_free_external(&ext); continue; } raw.h_name_hidden = (unsigned char)(0x0); BU_EXTERNAL_INIT(&tmp); db5_export_object3(&tmp, DB5HDR_HFLAGS_DLI_APPLICATION_DATA_OBJECT, dp->d_namep, raw.h_name_hidden, &raw.attributes, &raw.body, raw.major_type, raw.minor_type, raw.a_zzz, raw.b_zzz); bu_free_external(&ext); if (db_put_external(&tmp, dp, dbip)) { bu_vls_printf(gedp->ged_result_str, "db_put_external() failed for %s\n", dp->d_namep); bu_free_external(&tmp); continue; } bu_free_external(&tmp); dp->d_flags &= (~RT_DIR_HIDDEN); } return GED_OK; }
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; }
/** * Apply a 4x4 transformation matrix to the internal form of a solid. * * If "free" flag is non-zero, storage for the original solid is * released. If "os" is same as "is", storage for the original solid * is overwritten with the new, transformed solid. * * Returns - * -1 FAIL * 0 OK */ int rt_generic_xform( struct rt_db_internal *op, const mat_t mat, struct rt_db_internal *ip, int release, struct db_i *dbip, struct resource *resp) { struct bu_external ext; int id; struct bu_attribute_value_set avs; RT_CK_DB_INTERNAL(ip); RT_CK_DBI(dbip); RT_CK_RESOURCE(resp); memset(&avs, 0, sizeof(struct bu_attribute_value_set)); id = ip->idb_type; BU_EXTERNAL_INIT(&ext); /* Scale change on export is 1.0 -- no change */ switch (db_version(dbip)) { case 4: if (OBJ[id].ft_export4(&ext, ip, 1.0, dbip, resp) < 0) { bu_log("rt_generic_xform(): %s export failure\n", OBJ[id].ft_name); return -1; /* FAIL */ } if ((release || op == ip)) rt_db_free_internal(ip); RT_DB_INTERNAL_INIT(op); if (OBJ[id].ft_import4(op, &ext, mat, dbip, resp) < 0) { bu_log("rt_generic_xform(): solid import failure\n"); return -1; /* FAIL */ } break; case 5: if (OBJ[id].ft_export5(&ext, ip, 1.0, dbip, resp) < 0) { bu_log("rt_generic_xform(): %s export failure\n", OBJ[id].ft_name); return -1; /* FAIL */ } if ((release || op == ip)) { if (ip->idb_avs.magic == BU_AVS_MAGIC) { /* grab the attributes before they are lost * by rt_db_free_internal or RT_DB_INTERNAL_INIT */ bu_avs_init(&avs, ip->idb_avs.count, "avs"); bu_avs_merge(&avs, &ip->idb_avs); } rt_db_free_internal(ip); } RT_DB_INTERNAL_INIT(op); if (!release && op != ip) { /* just copy the attributes from ip to op */ if (ip->idb_avs.magic == BU_AVS_MAGIC) { bu_avs_init(&op->idb_avs, ip->idb_avs.count, "avs"); bu_avs_merge(&op->idb_avs, &ip->idb_avs); } } else if (avs.magic == BU_AVS_MAGIC) { /* put the saved attributes in the output */ bu_avs_init(&op->idb_avs, avs.count, "avs"); bu_avs_merge(&op->idb_avs, &avs); bu_avs_free(&avs); } if (OBJ[id].ft_import5(op, &ext, mat, dbip, resp) < 0) { bu_log("rt_generic_xform(): solid import failure\n"); return -1; /* FAIL */ } break; } bu_free_external(&ext); RT_CK_DB_INTERNAL(op); return 0; /* OK */ }
or poly-bot file_poly.g file_bot.g\n\ Convert polysolids to BOT solids in v4 database format only\n"; int main(int argc, char **argv) { FILE *ifp; FILE *ofp; union record record; union record *poly; long poly_limit=0; long curr_poly=0; struct bn_tol tol; int polys=0; int frees=0; int others=0; int bots=0; int i; int num_rec; int first=1; bu_setprogname(argv[0]); ifp = stdin; ofp = stdout; /* 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; if (argc >= 3) { ifp = fopen(argv[1], "rb"); if (!ifp) perror(argv[1]); ofp = fopen(argv[2], "wb"); if (!ofp) perror(argv[2]); if (ifp == NULL || ofp == NULL) { bu_exit(1, "poly-bot: can't open files."); } #if defined(_WIN32) && !defined(__CYGWIN__) } else { setmode(fileno(ifp), O_BINARY); setmode(fileno(ofp), O_BINARY); #endif } if (isatty(fileno(ifp))) { bu_exit(1, "%s", usage); } poly = (union record *)bu_malloc( POLY_BLOCK * sizeof( union record ), "poly" ); poly_limit = POLY_BLOCK; /* Read database file */ while ( fread( (char *)&record, sizeof record, 1, ifp ) == 1 && !feof(ifp) ) { top: switch ( record.u_id ) { case ID_FREE: frees++; continue; case DBID_SKETCH: num_rec = ntohl(*(uint32_t *)&record.skt.skt_count); others += num_rec + 1; if ( fwrite( &record, sizeof( union record ), 1, ofp ) < 1 ) bu_exit(1, "Write failed!\n" ); for ( i=0; i<num_rec; i++ ) { if ( fread( (char *)&record, sizeof record, 1, ifp ) != 1 ) bu_exit(1, "Unexpected EOF encountered while copying a SKETCH\n" ); if ( fwrite( &record, sizeof( union record ), 1, ofp ) < 1 ) bu_exit(1, "Write failed!\n" ); } break; case DBID_EXTR: num_rec = ntohl(*(uint32_t *)&record.extr.ex_count); others += num_rec + 1; if ( fwrite( &record, sizeof( union record ), 1, ofp ) < 1 ) bu_exit(1, "Write failed!\n" ); for ( i=0; i<num_rec; i++ ) { if ( fread( (char *)&record, sizeof record, 1, ifp ) != 1 ) bu_exit(1, "Unexpected EOF encountered while copying an EXTRUSION\n" ); if ( fwrite( &record, sizeof( union record ), 1, ofp ) < 1 ) bu_exit(1, "Write failed!\n" ); } break; case DBID_NMG: num_rec = ntohl(*(uint32_t *)&record.nmg.N_count); others += num_rec + 1; if ( fwrite( &record, sizeof( union record ), 1, ofp ) < 1 ) bu_exit(1, "Write failed!\n" ); for ( i=0; i<num_rec; i++ ) { if ( fread( (char *)&record, sizeof record, 1, ifp ) != 1 ) bu_exit(1, "Unexpected EOF encountered while copying an ARBN\n" ); if ( fwrite( &record, sizeof( union record ), 1, ofp ) < 1 ) bu_exit(1, "Write failed!\n" ); } break; case DBID_PIPE: num_rec = ntohl(*(uint32_t *)&record.pwr.pwr_count); others += num_rec + 1; if ( fwrite( &record, sizeof( union record ), 1, ofp ) < 1 ) bu_exit(1, "Write failed!\n" ); for ( i=0; i<num_rec; i++ ) { if ( fread( (char *)&record, sizeof record, 1, ifp ) != 1 ) bu_exit(1, "Unexpected EOF encountered while copying a PIPE\n" ); if ( fwrite( &record, sizeof( union record ), 1, ofp ) < 1 ) bu_exit(1, "Write failed!\n" ); } break; case DBID_ARBN: num_rec = ntohl(*(uint32_t *)&record.n.n_grans); others += num_rec + 1; if ( fwrite( &record, sizeof( union record ), 1, ofp ) < 1 ) bu_exit(1, "Write failed!\n" ); for ( i=0; i<num_rec; i++ ) { if ( fread( (char *)&record, sizeof record, 1, ifp ) != 1 ) bu_exit(1, "Unexpected EOF encountered while copying an ARBN\n" ); if ( fwrite( &record, sizeof( union record ), 1, ofp ) < 1 ) bu_exit(1, "Write failed!\n" ); } break; case DBID_STRSOL: num_rec = DB_SS_NGRAN - 1; others += num_rec + 1; if ( fwrite( &record, sizeof( union record ), 1, ofp ) < 1 ) bu_exit(1, "Write failed!\n" ); for ( i=0; i<num_rec; i++ ) { if ( fread( (char *)&record, sizeof record, 1, ifp ) != 1 ) bu_exit(1, "Unexpected EOF encountered while copying a STRSOL\n" ); if ( fwrite( &record, sizeof( union record ), 1, ofp ) < 1 ) bu_exit(1, "Write failed!\n" ); } break; case ID_BSURF: num_rec = record.d.d_nknots + record.d.d_nctls; others += num_rec + 1; if ( fwrite( &record, sizeof( union record ), 1, ofp ) < 1 ) bu_exit(1, "Write failed!\n" ); for ( i=0; i<num_rec; i++ ) { if ( fread( (char *)&record, sizeof record, 1, ifp ) != 1 ) bu_exit(1, "Unexpected EOF encountered while copying a NURB\n" ); if ( fwrite( &record, sizeof( union record ), 1, ofp ) < 1 ) bu_exit(1, "Write failed!\n" ); } break; case DBID_BOT: bots++; if ( fwrite( &record, sizeof( union record ), 1, ofp ) < 1 ) bu_exit(1, "Write failed!\n" ); num_rec = ntohl(*(uint32_t *)&record.bot.bot_nrec); for ( i=0; i<num_rec; i++ ) { if ( fread( (char *)&record, sizeof record, 1, ifp ) != 1 ) bu_exit(1, "Unexpected EOF encountered while copying a BOT\n" ); if ( fwrite( &record, sizeof( union record ), 1, ofp ) < 1 ) bu_exit(1, "Write failed!\n" ); } break; case ID_P_HEAD: { struct rt_db_internal intern; struct bu_external ext; struct bu_external ext2; polys++; curr_poly = 0; poly[curr_poly++] = record; /* struct copy */ bu_log( "Converting %s\n", poly[0].p.p_name ); while ( fread( (char *)&record, sizeof record, 1, ifp ) == 1 && !feof(ifp) && record.u_id == ID_P_DATA ) { if ( curr_poly >= poly_limit ) { poly_limit += POLY_BLOCK; poly = (union record *)bu_realloc( poly, poly_limit*sizeof( union record ), "poly realloc" ); } poly[curr_poly++] = record; /* struct copy */ } BU_EXTERNAL_INIT( &ext ); ext.ext_nbytes = curr_poly * sizeof( union record ); ext.ext_buf = (uint8_t *)poly; if ( rt_functab[ID_POLY].ft_import4( &intern, &ext, bn_mat_identity, (struct db_i *)NULL, &rt_uniresource ) ) { bu_exit(1, "Import failed for polysolid %s\n", poly[0].p.p_name ); } /* Don't free this ext buffer! */ if ( rt_pg_to_bot( &intern, &tol, &rt_uniresource ) < 0 ) { bu_exit(1, "Unable to convert polysolid %s\n", poly[0].p.p_name ); } BU_EXTERNAL_INIT( &ext2 ); if ( rt_functab[ID_POLY].ft_export4( &ext2, &intern, 1.0, (struct db_i *)NULL, &rt_uniresource ) < 0 ) { bu_exit(1, "Unable to export v4 BoT %s\n", poly[0].p.p_name ); } rt_db_free_internal(&intern); if ( db_fwrite_external( ofp, poly[0].p.p_name, &ext2 ) < 0 ) { bu_exit(1, "Unable to fwrite v4 BoT %s\n", poly[0].p.p_name ); } bu_free_external( &ext2 ); if ( feof( ifp ) ) break; goto top; } case ID_P_DATA: /* This should not happen! */ bu_log( "ERROR: Unattached polysolid data record!\n" ); continue; default: if ( first ) { if ( record.u_id != ID_IDENT ) { bu_exit(1, "This is not a BRL-CAD 'v4' database, aborting.\n" ); } first = 0; } others++; if ( fwrite( &record, sizeof( union record ), 1, ofp ) < 1 ) bu_exit(1, "Write failed!\n" ); } } bu_log( "%d polysolids converted to BOT solids\n", polys ); bu_log( "%d BOT solids copied without change\n", bots ); bu_log( "%d other records copied without change\n", others ); bu_log( "%d free records skipped\n", frees ); fclose(ofp); return 0; }
int ged_dbcopy(struct ged *from_gedp, struct ged *to_gedp, const char *from, const char *to, int fflag) { struct directory *from_dp; struct bu_external external; GED_CHECK_DATABASE_OPEN(from_gedp, GED_ERROR); GED_CHECK_DATABASE_OPEN(to_gedp, GED_ERROR); GED_CHECK_READ_ONLY(to_gedp, GED_ERROR); /* initialize result */ bu_vls_trunc(from_gedp->ged_result_str, 0); bu_vls_trunc(to_gedp->ged_result_str, 0); GED_DB_LOOKUP(from_gedp, from_dp, from, LOOKUP_NOISY, GED_ERROR & GED_QUIET); if (!fflag && db_lookup(to_gedp->ged_wdbp->dbip, to, LOOKUP_QUIET) != RT_DIR_NULL) { bu_vls_printf(from_gedp->ged_result_str, "%s already exists.", to); return GED_ERROR; } if (db_get_external(&external, from_dp, from_gedp->ged_wdbp->dbip)) { bu_vls_printf(from_gedp->ged_result_str, "Database read error, aborting\n"); return GED_ERROR; } if (wdb_export_external(to_gedp->ged_wdbp, &external, to, from_dp->d_flags, from_dp->d_minor_type) < 0) { bu_free_external(&external); bu_vls_printf(from_gedp->ged_result_str, "Failed to write new object (%s) to database - aborting!!\n", to); return GED_ERROR; } bu_free_external(&external); /* Need to do something extra for _GLOBAL */ if (db_version(to_gedp->ged_wdbp->dbip) > 4 && BU_STR_EQUAL(to, DB5_GLOBAL_OBJECT_NAME)) { struct directory *to_dp; struct bu_attribute_value_set avs; const char *val; GED_DB_LOOKUP(to_gedp, to_dp, to, LOOKUP_NOISY, GED_ERROR & GED_QUIET); bu_avs_init_empty(&avs); if (db5_get_attributes(to_gedp->ged_wdbp->dbip, &avs, to_dp)) { bu_vls_printf(from_gedp->ged_result_str, "Cannot get attributes for object %s\n", to_dp->d_namep); return GED_ERROR; } if ((val = bu_avs_get(&avs, "title")) != NULL) to_gedp->ged_wdbp->dbip->dbi_title = strdup(val); if ((val = bu_avs_get(&avs, "units")) != NULL) { double loc2mm; if ((loc2mm = bu_mm_value(val)) > 0) { to_gedp->ged_wdbp->dbip->dbi_local2base = loc2mm; to_gedp->ged_wdbp->dbip->dbi_base2local = 1.0 / loc2mm; } } if ((val = bu_avs_get(&avs, "regionid_colortable")) != NULL) { rt_color_free(); db5_import_color_table((char *)val); } bu_avs_free(&avs); } return GED_OK; }
static int db_corrupt_handler(struct db_i *dbip, const char *name, off_t offset, size_t size, int UNUSED(type), void *data) { struct counter *cnt = (struct counter *)data; struct bu_external ext; union record *rp = NULL; mat_t diskmat = MAT_INIT_ZERO; size_t nodecount; size_t j; int ret; RT_CK_DBI(dbip); /* get into position */ ret = bu_fseek(dbip->dbi_fp, offset, 0); if (ret) { bu_log("Database seek failure, unable to seek [%s]\n", name); return 0; } /* set up our buffer */ BU_EXTERNAL_INIT(&ext); ext.ext_nbytes = size * sizeof(union record); ext.ext_buf = (uint8_t *)bu_calloc(ext.ext_nbytes, 1, "db_corrupt"); /* read into the buffer */ j = (size_t)fread(ext.ext_buf, 1, ext.ext_nbytes, dbip->dbi_fp); if (j != ext.ext_nbytes) { bu_log("Database read failure, unable to read [%s]\n", name); bu_free_external(&ext); return 0; } rp = (union record *)ext.ext_buf; if (rp[0].u_id != ID_COMB) { /* skip non-combination */ bu_free_external(&ext); return 0; } /* iterate over combination members, looking for bad matrices */ nodecount = ext.ext_nbytes/sizeof(union record) - 1; for (j = 0; j < nodecount; j++) { /* try without flipping */ flip_mat_dbmat(diskmat, rp[j+1].M.m_mat, 0); if ((bn_mat_ck(name, diskmat) < 0) || fabs(diskmat[0]) > 1 || fabs(diskmat[1]) > 1 || fabs(diskmat[2]) > 1 || fabs(diskmat[4]) > 1 || fabs(diskmat[5]) > 1 || fabs(diskmat[6]) > 1 || fabs(diskmat[8]) > 1 || fabs(diskmat[9]) > 1 || fabs(diskmat[10]) > 1) { /* corruption detected */ cnt->found++; /* invalid, so try flipped */ flip_mat_dbmat(diskmat, rp[j+1].M.m_mat, 1); if ((bn_mat_ck(name, diskmat) < 0) || fabs(diskmat[0]) > 1 || fabs(diskmat[1]) > 1 || fabs(diskmat[2]) > 1 || fabs(diskmat[4]) > 1 || fabs(diskmat[5]) > 1 || fabs(diskmat[6]) > 1 || fabs(diskmat[8]) > 1 || fabs(diskmat[9]) > 1 || fabs(diskmat[10]) > 1) { bu_log("WARNING: Invalid matrix detected within %s\n", name); } else { /* flipping helped */ cnt->fixed++; } break; } } bu_free_external(&ext); return 0; }
int rt_binunif_tclget(Tcl_Interp *interp, const struct rt_db_internal *intern, const char *attr ) { register struct rt_binunif_internal *bip=(struct rt_binunif_internal *)intern->idb_ptr; struct bu_external ext; Tcl_DString ds; struct bu_vls vls; int status=TCL_OK; int i; unsigned char *c; RT_CHECK_BINUNIF( bip ); Tcl_DStringInit( &ds ); bu_vls_init( &vls ); if ( attr == (char *)NULL ) { /* export the object to get machine independent form */ if ( rt_binunif_export5( &ext, intern, 1.0, NULL, NULL, intern->idb_minor_type ) ) { bu_vls_strcpy( &vls, "Failed to export binary object!!\n" ); status = TCL_ERROR; } else { bu_vls_strcpy( &vls, "binunif" ); bu_vls_printf( &vls, " T %d D {", bip->type ); c = ext.ext_buf; for ( i=0; i<ext.ext_nbytes; i++, c++ ) { if ( i%40 == 0 ) bu_vls_strcat( &vls, "\n" ); bu_vls_printf( &vls, "%2.2x", *c ); } bu_vls_strcat( &vls, "}" ); bu_free_external( &ext ); } } else { if ( !strcmp( attr, "T" ) ) { bu_vls_printf( &vls, "%d", bip->type ); } else if ( !strcmp( attr, "D" ) ) { /* export the object to get machine independent form */ if ( rt_binunif_export5( &ext, intern, 1.0, NULL, NULL, intern->idb_minor_type ) ) { bu_vls_strcpy( &vls, "Failed to export binary object!!\n" ); status = TCL_ERROR; } else { c = ext.ext_buf; for ( i=0; i<ext.ext_nbytes; i++, c++ ) { if ( i != 0 && i%40 == 0 ) bu_vls_strcat( &vls, "\n" ); bu_vls_printf( &vls, "%2.2x", *c ); } bu_free_external( &ext ); } } else { bu_vls_printf( &vls, "Binary object has no attribute '%s'", attr ); status = TCL_ERROR; } } Tcl_DStringAppend( &ds, bu_vls_addr( &vls ), -1 ); Tcl_DStringResult( interp, &ds ); Tcl_DStringFree( &ds ); bu_vls_free( &vls ); return( status ); }
int rt_retrieve_binunif(struct rt_db_internal *intern, struct db_i *dbip, char *name) { register struct directory *dp; struct rt_binunif_internal *bip; struct bu_external ext; struct db5_raw_internal raw; char *tmp; /* *Find the guy we're told to write */ if ( (dp = db_lookup( dbip, name, LOOKUP_NOISY)) == DIR_NULL ) return -1; RT_INIT_DB_INTERNAL(intern); if ( rt_db_get_internal5( intern, dp, dbip, NULL, &rt_uniresource) != ID_BINUNIF || db_get_external( &ext, dp, dbip ) < 0 ) return -1; if (db5_get_raw_internal_ptr(&raw, ext.ext_buf) == NULL) { bu_log("%s:%d\n", __FILE__, __LINE__); bu_free_external( &ext ); return -1; } if (db5_type_descrip_from_codes(&tmp, raw.major_type, raw.minor_type)) tmp = 0; if (RT_G_DEBUG & DEBUG_VOL) bu_log("get_body() sees type (%d, %d)='%s'\n", raw.major_type, raw.minor_type, tmp); if (raw.major_type != DB5_MAJORTYPE_BINARY_UNIF) return -1; bip = intern->idb_ptr; RT_CK_BINUNIF(bip); if (RT_G_DEBUG & DEBUG_HF) rt_binunif_dump(bip); if (RT_G_DEBUG & DEBUG_VOL) bu_log("cmd_export_body() thinks bip->count=%d\n", bip->count); switch (bip -> type) { case DB5_MINORTYPE_BINU_FLOAT: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... float"); break; case DB5_MINORTYPE_BINU_DOUBLE: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... double"); break; case DB5_MINORTYPE_BINU_8BITINT: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... 8bitint"); break; case DB5_MINORTYPE_BINU_8BITINT_U: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... 8bituint"); break; case DB5_MINORTYPE_BINU_16BITINT: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... 16bituint"); break; case DB5_MINORTYPE_BINU_16BITINT_U: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... 16bitint"); break; case DB5_MINORTYPE_BINU_32BITINT: case DB5_MINORTYPE_BINU_32BITINT_U: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... 32bitint"); break; case DB5_MINORTYPE_BINU_64BITINT: case DB5_MINORTYPE_BINU_64BITINT_U: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... 64bitint"); break; default: /* XXX This shouln't happen!! */ bu_log("bip->type switch... default"); break; } bu_free_external( &ext ); return 0; }
/* * C M D _ E X P O R T _ B O D Y ( ) * * Write an object's body to disk file * */ int cmd_export_body(ClientData clientData, Tcl_Interp *interp, int argc, char **argv) { register struct directory *dp; int fd; void *bufp; size_t nbytes = 0; long int written; struct bu_external ext; struct db5_raw_internal raw; struct rt_db_internal intern; struct rt_binunif_internal *bip; struct bu_vls vls; #if 0 int status; #endif char *tmp; CHECK_DBI_NULL; if (argc != 3) { bu_vls_init(&vls); bu_vls_printf(&vls, "help %s", argv[0]); Tcl_Eval(interp, bu_vls_addr(&vls)); bu_vls_free(&vls); return TCL_ERROR; } /* * Find the guy we're told to write */ if ( (dp = db_lookup( dbip, argv[2], LOOKUP_NOISY)) == DIR_NULL ) { bu_vls_init( &vls ); bu_vls_printf( &vls, "Cannot find object %s for writing\n", argv[2] ); Tcl_SetResult(interp, bu_vls_addr( &vls ), TCL_VOLATILE ); bu_vls_free( &vls ); mged_print_result( TCL_ERROR ); return TCL_ERROR; } RT_INIT_DB_INTERNAL(&intern); if ( rt_db_get_internal5( &intern, dp, dbip, NULL, &rt_uniresource) != ID_BINUNIF || db_get_external( &ext, dp, dbip ) < 0 ) { (void)signal( SIGINT, SIG_IGN ); TCL_READ_ERR_return; } if (db5_get_raw_internal_ptr(&raw, ext.ext_buf) == NULL) { bu_free_external( &ext ); (void)signal( SIGINT, SIG_IGN ); TCL_READ_ERR_return; } /* * Do the writing */ #ifndef _WIN32 if ( (fd = creat( argv[1], S_IRWXU | S_IRGRP | S_IROTH )) == -1 ) { #else if ( (fd = creat( argv[1], _S_IREAD | _S_IWRITE )) == -1 ) { #endif bu_free_external( &ext ); bu_vls_init( &vls ); bu_vls_printf( &vls, "Cannot open file %s for writing\n", argv[1] ); Tcl_SetResult(interp, bu_vls_addr( &vls ), TCL_VOLATILE ); bu_vls_free( &vls ); mged_print_result( TCL_ERROR ); return TCL_ERROR; } if (db5_type_descrip_from_codes(&tmp, raw.major_type, raw.minor_type)) tmp = 0; if (RT_G_DEBUG & DEBUG_VOL) bu_log("cmd_export_body() sees type (%d, %d)='%s'\n", raw.major_type, raw.minor_type, tmp); switch (raw.major_type) { case DB5_MAJORTYPE_BINARY_UNIF: #if 0 if ( rt_binunif_import5( &intern, &ext, 0, dbip, &rt_uniresource, raw.minor_type ) ) { (void)signal( SIGINT, SIG_IGN ); TCL_READ_ERR_return; } #endif bip = (struct rt_binunif_internal *) intern.idb_ptr; RT_CK_BINUNIF(bip); rt_binunif_dump(bip); bufp = (void *) bip->u.uint8; bu_log("cmd_export_body() thinks bip->count=%d\n", bip->count); switch (bip -> type) { case DB5_MINORTYPE_BINU_FLOAT: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... float"); nbytes = (size_t) (bip->count * sizeof(float)); break; case DB5_MINORTYPE_BINU_DOUBLE: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... double"); nbytes = (size_t) (bip->count * sizeof(double)); break; case DB5_MINORTYPE_BINU_8BITINT: case DB5_MINORTYPE_BINU_8BITINT_U: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... 8bitint"); nbytes = (size_t) (bip->count); break; case DB5_MINORTYPE_BINU_16BITINT: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... 16bitint"); nbytes = (size_t) (bip->count * 2); bu_log("data[0] = %u\n", bip->u.uint16[0]); break; case DB5_MINORTYPE_BINU_16BITINT_U: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... 16bituint"); nbytes = (size_t) (bip->count * 2); bu_log("data[0] = %u\n", bip->u.uint16[0]); break; case DB5_MINORTYPE_BINU_32BITINT: case DB5_MINORTYPE_BINU_32BITINT_U: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... 32bitint"); nbytes = (size_t) (bip->count * 4); break; case DB5_MINORTYPE_BINU_64BITINT: case DB5_MINORTYPE_BINU_64BITINT_U: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... 64bitint"); nbytes = (size_t) (bip->count * 8); break; default: /* XXX This shouln't happen!! */ bu_log("bip->type switch... default"); break; } break; default: if (RT_G_DEBUG & DEBUG_VOL) bu_log("I'm in the default\n"); bufp = (void *) ext.ext_buf; nbytes = (size_t) ext.ext_nbytes; break; } if (RT_G_DEBUG & DEBUG_VOL) bu_log("going to write %ld bytes\n", nbytes); if ( (written = write(fd, bufp, nbytes) ) != nbytes ) { perror(argv[1]); bu_log("%s:%d\n", __FILE__, __LINE__); bu_free_external( &ext ); bu_vls_init( &vls ); bu_vls_printf( &vls, "Incomplete write of object %s to file %s, got %ld, s/b=%ld\n", argv[2], argv[1], written, nbytes ); Tcl_SetResult(interp, bu_vls_addr( &vls ), TCL_VOLATILE ); bu_vls_free( &vls ); mged_print_result( TCL_ERROR ); return TCL_ERROR; } bu_free_external( &ext ); return TCL_OK; }
int rt_mk_binunif(struct rt_wdb *wdbp, const char *obj_name, const char *file_name, unsigned int minor_type, long max_count) { struct stat st; unsigned int major_type=DB5_MAJORTYPE_BINARY_UNIF; #if defined(_WIN32) && !defined(__CYGWIN__) __int64 num_items=-1; __int64 obj_length=-1; #else long long num_items=-1; long long obj_length=-1; #endif int item_length=0; struct bu_mapped_file *bu_fd; struct rt_binunif_internal *bip; struct rt_db_internal intern; struct bu_external body; struct bu_external bin_ext; struct directory *dp; if ( (item_length=db5_type_sizeof_h_binu( minor_type ) ) <= 0 ) { bu_log( "Unrecognized minor type!!!\n" ); return -1; } if ( stat( file_name, &st ) ) { bu_log( "Cannot stat input file(%s)", file_name ); return -1; } if ( (bu_fd=bu_open_mapped_file( file_name, NULL)) == NULL ) { bu_log( "Cannot open input file(%s) for reading", file_name ); return -1; } /* create the rt_binunif internal form */ BU_GETSTRUCT( bip, rt_binunif_internal ); bip->magic = RT_BINUNIF_INTERNAL_MAGIC; bip->type = minor_type; num_items = (long)(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 > __LONG_MAX__) { bu_log("Unable to create binary objects larger than %ld bytes\n", __LONG_MAX__); return -1; } /* just copy the bytes */ bip->count = 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_INIT_DB_INTERNAL( &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 */ if ( intern.idb_meth->ft_export5( &body, &intern, 1.0, wdbp->dbip, wdbp->wdb_resp, intern.idb_minor_type ) ) { bu_log( "Error while attemptimg to export %s\n", obj_name ); rt_db_free_internal( &intern, wdbp->wdb_resp ); 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, wdbp->wdb_resp ); bu_free_external( &body ); /* add this object to the directory */ if ( (dp=db_diradd5( wdbp->dbip, obj_name, -1, major_type, minor_type, 0, 0, NULL )) == DIR_NULL ) { bu_log( "Error while attemptimg 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; }