int
ged_perspective(struct ged *gedp, int argc, const char *argv[])
{
/* intentionally double for scan */
double perspective;
static const char *usage = "[angle]";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_VIEW(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* get the perspective angle */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "%g", gedp->ged_gvp->gv_perspective);
return GED_OK;
}
/* set perspective angle */
if (argc == 2) {
if (sscanf(argv[1], "%lf", &perspective) != 1) {
bu_vls_printf(gedp->ged_result_str, "bad perspective angle - %s", argv[1]);
return GED_ERROR;
}
gedp->ged_gvp->gv_perspective = perspective;
if (SMALL_FASTF < gedp->ged_gvp->gv_perspective) {
ged_persp_mat(gedp->ged_gvp->gv_pmat, gedp->ged_gvp->gv_perspective,
(fastf_t)1.0f, (fastf_t)0.01f, (fastf_t)1.0e10f, (fastf_t)1.0f);
} else {
MAT_COPY(gedp->ged_gvp->gv_pmat, bn_mat_identity);
}
ged_view_update(gedp->ged_gvp);
return GED_OK;
}
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
int
ged_size(struct ged *gedp, int argc, const char *argv[])
{
/* intentionally double for scan */
double size;
static const char *usage = "[s]";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_VIEW(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* get view size */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "%g",
gedp->ged_gvp->gv_size * gedp->ged_wdbp->dbip->dbi_base2local);
return GED_OK;
}
/* set view size */
if (argc == 2) {
if (sscanf(argv[1], "%lf", &size) != 1
|| size <= 0
|| ZERO(size))
{
bu_vls_printf(gedp->ged_result_str, "bad size - %s", argv[1]);
return GED_ERROR;
}
gedp->ged_gvp->gv_size = gedp->ged_wdbp->dbip->dbi_local2base * size;
if (gedp->ged_gvp->gv_size < RT_MINVIEWSIZE)
gedp->ged_gvp->gv_size = RT_MINVIEWSIZE;
gedp->ged_gvp->gv_isize = 1.0 / gedp->ged_gvp->gv_size;
gedp->ged_gvp->gv_scale = 0.5 * gedp->ged_gvp->gv_size;
ged_view_update(gedp->ged_gvp);
return GED_OK;
}
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
int
ged_quat(struct ged *gedp, int argc, const char *argv[])
{
quat_t quat;
double scan[4];
static const char *usage = "a b c d";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_VIEW(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* return Viewrot as a quaternion */
if (argc == 1) {
quat_mat2quat(quat, gedp->ged_gvp->gv_rotation);
bu_vls_printf(gedp->ged_result_str, "%.12g %.12g %.12g %.12g", V4ARGS(quat));
return GED_OK;
}
if (argc != 5) {
bu_vls_printf(gedp->ged_result_str, "Usage: view %s %s", argv[0], usage);
return GED_ERROR;
}
/* Set the view orientation given a quaternion */
if (sscanf(argv[1], "%lf", &scan[0]) != 1
|| sscanf(argv[2], "%lf", &scan[1]) != 1
|| sscanf(argv[3], "%lf", &scan[2]) != 1
|| sscanf(argv[4], "%lf", &scan[3]) != 1)
{
bu_vls_printf(gedp->ged_result_str, "view %s: bad value detected - %s %s %s %s",
argv[0], argv[1], argv[2], argv[3], argv[4]);
return GED_ERROR;
}
HMOVE(quat, scan);
quat_quat2mat(gedp->ged_gvp->gv_rotation, quat);
ged_view_update(gedp->ged_gvp);
return GED_OK;
}
int
ged_reopen(struct ged *gedp, int argc, const char *argv[])
{
struct db_i *dbip;
static const char *usage = "[filename]";
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);
/* get database filename */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "%s", gedp->ged_wdbp->dbip->dbi_filename);
return GED_OK;
}
/* set database filename */
if (argc == 2) {
char *av[2];
if ((dbip = _ged_open_dbip(argv[1], 0)) == DBI_NULL) {
bu_vls_printf(gedp->ged_result_str, "ged_reopen: failed to open %s\n", argv[1]);
return GED_ERROR;
}
av[0] = "zap";
av[1] = (char *)0;
ged_zap(gedp, 1, (const char **)av);
/* close current database */
db_close(gedp->ged_wdbp->dbip);
gedp->ged_wdbp->dbip = dbip;
bu_vls_printf(gedp->ged_result_str, "%s", gedp->ged_wdbp->dbip->dbi_filename);
return GED_OK;
}
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
int
ged_whatid(struct ged *gedp, int argc, const char *argv[])
{
struct directory *dp;
struct rt_db_internal intern;
struct rt_comb_internal *comb;
static const char *usage = "region";
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", argv[0], usage);
return GED_HELP;
}
if (argc != 2) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
if ((dp=db_lookup(gedp->ged_wdbp->dbip, argv[1], LOOKUP_NOISY)) == RT_DIR_NULL)
return GED_ERROR;
if (!(dp->d_flags & RT_DIR_REGION)) {
bu_vls_printf(gedp->ged_result_str, "%s is not a region", argv[1]);
return GED_ERROR;
}
if (rt_db_get_internal(&intern, dp, gedp->ged_wdbp->dbip, (fastf_t *)NULL, &rt_uniresource) < 0)
return GED_ERROR;
comb = (struct rt_comb_internal *)intern.idb_ptr;
bu_vls_printf(gedp->ged_result_str, "%ld", comb->region_id);
rt_db_free_internal(&intern);
return GED_OK;
}
int
ged_view2model(struct ged *gedp, int argc, const char *argv[])
{
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_VIEW(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* get the view2model matrix */
if (argc == 1) {
bn_encode_mat(gedp->ged_result_str, gedp->ged_gvp->gv_view2model);
return GED_OK;
}
bu_vls_printf(gedp->ged_result_str, "Usage: %s", argv[0]);
return GED_ERROR;
}
HIDDEN void
reassemble_argstr(struct bu_vls *instr, struct bu_vls *outstr, option::Option *unknowns)
{
for (option::Option* opt = unknowns; opt; opt = opt->next()) {
int input_only = 0;
int output_only = 0;
char *inputcpy = NULL;
if (!instr || !outstr) return;
inputcpy = bu_strdup(opt->name);
if (!bu_strncmp(inputcpy, "--in-", 5)) input_only = 1;
if (!bu_strncmp(inputcpy, "--out-", 5)) output_only = 1;
char *equal_pos = strchr(inputcpy, '=');
if (equal_pos) {
struct bu_vls vopt = BU_VLS_INIT_ZERO;
struct bu_vls varg = BU_VLS_INIT_ZERO;
bu_vls_sprintf(&vopt, "%s", inputcpy);
bu_vls_trunc(&vopt, -1 * strlen(equal_pos));
bu_vls_sprintf(&varg, "%s", inputcpy);
bu_vls_nibble(&varg, strlen(inputcpy) - strlen(equal_pos) + 1);
if (!output_only) {
(bu_vls_strlen(&vopt) == 1) ? bu_vls_printf(instr, "-%s ", bu_vls_addr(&vopt)) : bu_vls_printf(instr, "%s ", bu_vls_addr(&vopt));
if (bu_vls_strlen(&varg)) bu_vls_printf(instr, "%s ", bu_vls_addr(&varg));
}
if (!input_only) {
(bu_vls_strlen(&vopt) == 1) ? bu_vls_printf(outstr, "-%s ", bu_vls_addr(&vopt)) : bu_vls_printf(outstr, "%s ", bu_vls_addr(&vopt));
if (bu_vls_strlen(&varg)) bu_vls_printf(outstr, "%s ", bu_vls_addr(&varg));
}
bu_vls_free(&vopt);
bu_vls_free(&varg);
} else {
if (!output_only) {
(strlen(opt->name) == 1) ? bu_vls_printf(instr, "-%s ", opt->name) : bu_vls_printf(instr, "%s ", opt->name);
if (opt->arg) bu_vls_printf(instr, "%s ", opt->arg);
}
if (!input_only) {
(strlen(opt->name) == 1) ? bu_vls_printf(outstr, "-%s ", opt->name) : bu_vls_printf(outstr, "%s ", opt->name);
if (opt->arg) bu_vls_printf(outstr, "%s ", opt->arg);
}
}
bu_free(inputcpy, "input cpy");
}
}
int
ged_model2grid_lu(struct ged *gedp, int argc, const char *argv[])
{
fastf_t f;
point_t view_pt;
point_t model_pt;
point_t mo_view_pt; /* model origin in view space */
point_t diff;
double scan[3];
static const char *usage = "x y z";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_VIEW(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
if (argc != 4)
goto bad;
VSETALL(model_pt, 0.0);
MAT4X3PNT(mo_view_pt, gedp->ged_gvp->gv_model2view, model_pt);
if (sscanf(argv[1], "%lf", &scan[X]) != 1 ||
sscanf(argv[2], "%lf", &scan[Y]) != 1 ||
sscanf(argv[3], "%lf", &scan[Z]) != 1)
goto bad;
VSCALE(model_pt, scan, gedp->ged_wdbp->dbip->dbi_local2base);
MAT4X3PNT(view_pt, gedp->ged_gvp->gv_model2view, model_pt);
VSUB2(diff, view_pt, mo_view_pt);
f = gedp->ged_gvp->gv_scale * gedp->ged_wdbp->dbip->dbi_base2local;
VSCALE(diff, diff, f);
bu_vls_printf(gedp->ged_result_str, "%.15e %.15e", diff[X], diff[Y]);
return GED_OK;
bad:
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
/*
* Set/get the unix plot output mode
*
* Usage:
* set_uplotOutputMode [binary|text]
*
*/
int
ged_set_uplotOutputMode(struct ged *gedp, int argc, const char *argv[])
{
static const char *usage = "[binary|text]";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_DRAWABLE(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;
}
/* Get the plot output mode */
if (argc == 1) {
if (gedp->ged_gdp->gd_uplotOutputMode == PL_OUTPUT_MODE_BINARY)
bu_vls_printf(gedp->ged_result_str, "binary");
else
bu_vls_printf(gedp->ged_result_str, "text");
return GED_OK;
}
if (argv[1][0] == 'b' &&
BU_STR_EQUAL("binary", argv[1]))
gedp->ged_gdp->gd_uplotOutputMode = PL_OUTPUT_MODE_BINARY;
else if (argv[1][0] == 't' &&
BU_STR_EQUAL("text", argv[1]))
gedp->ged_gdp->gd_uplotOutputMode = PL_OUTPUT_MODE_TEXT;
else {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
return GED_OK;
}
int
ged_log(struct ged *gedp, int argc, const char *argv[])
{
static char *usage = "get|start|stop";
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 != 2) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
if (argv[1][0] == 'g' && BU_STR_EQUAL(argv[1], "get")) {
bu_vls_vlscatzap(gedp->ged_result_str, gedp->ged_log);
return GED_OK;
}
if (argv[1][0] == 's' && BU_STR_EQUAL(argv[1], "start")) {
bu_log_add_hook(log_hook, (void *)gedp->ged_log);
return GED_OK;
}
if (argv[1][0] == 's' && BU_STR_EQUAL(argv[1], "stop")) {
bu_log_delete_hook(log_hook, (void *)gedp->ged_log);
return GED_OK;
}
bu_log("Usage: %s %s ", argv[0], usage);
return GED_ERROR;
}
int
ged_dump(struct ged *gedp, int argc, const char *argv[])
{
struct rt_wdb *op;
int ret;
static const char *usage = "file.g";
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", argv[0], usage);
return GED_HELP;
}
if (argc != 2) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
if ((op = wdb_fopen(argv[1])) == RT_WDB_NULL) {
bu_vls_printf(gedp->ged_result_str, "dump: %s: cannot create", argv[1]);
return GED_ERROR;
}
ret = db_dump(op, gedp->ged_wdbp->dbip);
wdb_close(op);
if (ret < 0) {
bu_vls_printf(gedp->ged_result_str, "dump: %s: db_dump() error", argv[1]);
return GED_ERROR;
}
return GED_OK;
}
/**
*@brief
* Check a name against the global directory.
*/
static int
dup_dir_check(struct db_i *input_dbip, const char *name, off_t UNUSED(laddr), size_t UNUSED(len), int UNUSED(flags), void *ptr)
{
struct directory *dupdp;
struct bu_vls local = BU_VLS_INIT_ZERO;
struct dir_check_stuff *dcsp = (struct dir_check_stuff *)ptr;
if (dcsp->main_dbip == DBI_NULL)
return 0;
RT_CK_DBI(input_dbip);
/* Add the prefix, if any */
if (db_version(dcsp->main_dbip) < 5) {
if (dcsp->wdbp->wdb_ncharadd > 0) {
bu_vls_strncpy(&local, bu_vls_addr(&dcsp->wdbp->wdb_prestr), dcsp->wdbp->wdb_ncharadd);
bu_vls_strcat(&local, name);
} else {
bu_vls_strncpy(&local, name, _GED_V4_MAXNAME);
}
bu_vls_trunc(&local, _GED_V4_MAXNAME);
} else {
if (dcsp->wdbp->wdb_ncharadd > 0) {
bu_vls_vlscat(&local, &dcsp->wdbp->wdb_prestr);
bu_vls_strcat(&local, name);
} else {
bu_vls_strcat(&local, name);
}
}
/* Look up this new name in the existing (main) database */
if ((dupdp = db_lookup(dcsp->main_dbip, bu_vls_addr(&local), LOOKUP_QUIET)) != RT_DIR_NULL) {
/* Duplicate found, add it to the list */
dcsp->wdbp->wdb_num_dups++;
*dcsp->dup_dirp++ = dupdp;
}
bu_vls_free(&local);
return 0;
}
struct bu_vls *
bu_units_strings_vls()
{
register const struct cvt_tab *tp;
struct bu_vls *vlsp;
double prev_val = 0.0;
BU_ALLOC(vlsp, struct bu_vls);
bu_vls_init(vlsp);
for (tp=bu_units_length_tab; tp->name[0]; tp++) {
if (ZERO(prev_val - tp->val))
continue;
bu_vls_printf(vlsp, "%s, ", tp->name);
prev_val = tp->val;
}
/* Remove the last ", " */
bu_vls_trunc(vlsp, -2);
return vlsp;
}
int
ged_view2model_lu(struct ged *gedp, int argc, const char *argv[])
{
fastf_t sf;
point_t view_pt;
point_t model_pt;
double scan[3];
static const char *usage = "x y z";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_VIEW(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
if (argc != 4)
goto bad;
if (sscanf(argv[1], "%lf", &scan[X]) != 1 ||
sscanf(argv[2], "%lf", &scan[Y]) != 1 ||
sscanf(argv[3], "%lf", &scan[Z]) != 1)
goto bad;
/* convert from double to fastf_t */
VMOVE(view_pt, scan);
sf = 1.0 / (gedp->ged_gvp->gv_scale * gedp->ged_wdbp->dbip->dbi_base2local);
VSCALE(view_pt, view_pt, sf);
MAT4X3PNT(model_pt, gedp->ged_gvp->gv_view2model, view_pt);
VSCALE(model_pt, model_pt, gedp->ged_wdbp->dbip->dbi_base2local);
bn_encode_vect(gedp->ged_result_str, model_pt);
return GED_OK;
bad:
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
/**
* Given a point in model space coordinates (in mm) convert it to view
* (screen) coordinates which must be scaled to correspond to actual
* screen coordinates. If no input coordinates are supplied, the
* model2view matrix is displayed.
*/
int
ged_model2view(struct ged *gedp, int argc, const char *argv[])
{
point_t view_pt;
double model_pt[3]; /* intentionally double for scan */
static const char *usage = "[x y z]";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_VIEW(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* get the model2view matrix */
if (argc == 1) {
bn_encode_mat(gedp->ged_result_str, gedp->ged_gvp->gv_model2view);
return GED_OK;
}
if (argc != 4) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
if (sscanf(argv[1], "%lf", &model_pt[X]) != 1
|| sscanf(argv[2], "%lf", &model_pt[Y]) != 1
|| sscanf(argv[3], "%lf", &model_pt[Z]) != 1)
{
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
MAT4X3PNT(view_pt, gedp->ged_gvp->gv_model2view, model_pt);
bn_encode_vect(gedp->ged_result_str, view_pt);
return GED_OK;
}
int
ged_view2model_vec(struct ged *gedp, int argc, const char *argv[])
{
point_t model_vec;
point_t view_vec;
mat_t inv_Viewrot;
double scan[3];
static const char *usage = "x y z";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_VIEW(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
if (argc != 4)
goto bad;
if (sscanf(argv[1], "%lf", &scan[X]) != 1 ||
sscanf(argv[2], "%lf", &scan[Y]) != 1 ||
sscanf(argv[3], "%lf", &scan[Z]) != 1)
goto bad;
/* convert from double to fastf_t */
VMOVE(view_vec, scan);
bn_mat_inv(inv_Viewrot, gedp->ged_gvp->gv_rotation);
MAT4X3PNT(model_vec, inv_Viewrot, view_vec);
bn_encode_vect(gedp->ged_result_str, model_vec);
return GED_OK;
bad:
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
/*
* Abort the current raytrace processes.
*
* Usage:
* rtabort
*
*/
int
ged_rtabort(struct ged *gedp, int argc, const char *argv[])
{
struct ged_run_rt *rrp;
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_DRAWABLE(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
if (argc != 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s", argv[0]);
return GED_ERROR;
}
for (BU_LIST_FOR(rrp, ged_run_rt, &gedp->ged_gdp->gd_headRunRt.l)) {
bu_terminate(rrp->pid);
rrp->aborted = 1;
}
return GED_OK;
}
int
ged_redraw(struct ged *gedp, int argc, const char *argv[])
{
int ret;
struct display_list *gdlp;
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_DRAWABLE(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
RT_CHECK_DBI(gedp->ged_wdbp->dbip);
bu_vls_trunc(gedp->ged_result_str, 0);
if (argc == 1) {
/* redraw everything */
for (BU_LIST_FOR(gdlp, display_list, gedp->ged_gdp->gd_headDisplay))
{
ret = dl_redraw(gdlp, gedp->ged_wdbp->dbip, &gedp->ged_wdbp->wdb_initial_tree_state, gedp->ged_gvp, gedp->ged_create_vlist_callback);
if (ret < 0) {
bu_vls_printf(gedp->ged_result_str, "%s: redraw failure\n", argv[0]);
return GED_ERROR;
}
}
} else {
int
ged_otranslate(struct ged *gedp, int argc, const char *argv[])
{
struct directory *dp;
struct _ged_trace_data gtd;
struct rt_db_internal intern;
vect_t delta;
double scan[3];
mat_t dmat;
mat_t emat;
mat_t tmpMat;
mat_t invXform;
point_t rpp_min;
point_t rpp_max;
static const char *usage = "obj dx dy dz";
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 != 5) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
if (_ged_get_obj_bounds2(gedp, 1, argv+1, >d, rpp_min, rpp_max) == GED_ERROR)
return GED_ERROR;
dp = gtd.gtd_obj[gtd.gtd_objpos-1];
if (!(dp->d_flags & RT_DIR_SOLID)) {
if (_ged_get_obj_bounds(gedp, 1, argv+1, 1, rpp_min, rpp_max) == GED_ERROR)
return GED_ERROR;
}
if (sscanf(argv[2], "%lf", &scan[X]) != 1) {
bu_vls_printf(gedp->ged_result_str, "%s: bad x value - %s", argv[0], argv[2]);
return GED_ERROR;
}
if (sscanf(argv[3], "%lf", &scan[Y]) != 1) {
bu_vls_printf(gedp->ged_result_str, "%s: bad y value - %s", argv[0], argv[3]);
return GED_ERROR;
}
if (sscanf(argv[4], "%lf", &scan[Z]) != 1) {
bu_vls_printf(gedp->ged_result_str, "%s: bad z value - %s", argv[0], argv[4]);
return GED_ERROR;
}
MAT_IDN(dmat);
VSCALE(delta, scan, gedp->ged_wdbp->dbip->dbi_local2base);
MAT_DELTAS_VEC(dmat, delta);
bn_mat_inv(invXform, gtd.gtd_xform);
bn_mat_mul(tmpMat, invXform, dmat);
bn_mat_mul(emat, tmpMat, gtd.gtd_xform);
GED_DB_GET_INTERNAL(gedp, &intern, dp, emat, &rt_uniresource, GED_ERROR);
RT_CK_DB_INTERNAL(&intern);
GED_DB_PUT_INTERNAL(gedp, dp, &intern, &rt_uniresource, GED_ERROR);
return GED_OK;
}
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
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
ged_bev(struct ged *gedp, int argc, const char *argv[])
{
static const char *usage = "[P|t] new_obj obj1 op obj2 op obj3 ...";
int i;
int c;
int ncpu;
char *cmdname;
char *newname;
struct rt_db_internal intern;
struct directory *dp;
char op;
int failed;
/* static due to longjmp */
static int triangulate = 0;
static union tree *tmp_tree = NULL;
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;
}
cmdname = (char *)argv[0];
/* Establish tolerances */
gedp->ged_wdbp->wdb_initial_tree_state.ts_ttol = &gedp->ged_wdbp->wdb_ttol;
gedp->ged_wdbp->wdb_initial_tree_state.ts_tol = &gedp->ged_wdbp->wdb_tol;
gedp->ged_wdbp->wdb_ttol.magic = RT_TESS_TOL_MAGIC;
/* Initial values for options, must be reset each time */
ncpu = 1;
triangulate = 0;
/* Parse options. */
bu_optind = 1; /* re-init bu_getopt() */
while ((c=bu_getopt(argc, (char * const *)argv, "tP:")) != -1) {
switch (c) {
case 'P':
#if 0
/* not yet supported */
ncpu = atoi(bu_optarg);
#endif
break;
case 't':
triangulate = 1;
break;
default: {
bu_vls_printf(gedp->ged_result_str, "%s: option '%c' unknown\n", cmdname, c);
}
break;
}
}
argc -= bu_optind;
argv += bu_optind;
newname = (char *)argv[0];
argv++;
argc--;
if (argc < 1) {
bu_vls_printf(gedp->ged_result_str, "%s: Nothing to evaluate!!!\n", cmdname);
return GED_ERROR;
}
GED_CHECK_EXISTS(gedp, newname, LOOKUP_QUIET, GED_ERROR);
bu_vls_printf(gedp->ged_result_str,
"%s: tessellating primitives with tolerances a=%g, r=%g, n=%g\n",
argv[0],
gedp->ged_wdbp->wdb_ttol.abs,
gedp->ged_wdbp->wdb_ttol.rel,
gedp->ged_wdbp->wdb_ttol.norm);
bev_facetize_tree = (union tree *)0;
bev_nmg_model = nmg_mm();
gedp->ged_wdbp->wdb_initial_tree_state.ts_m = &bev_nmg_model;
op = ' ';
tmp_tree = (union tree *)NULL;
while (argc) {
i = db_walk_tree(gedp->ged_wdbp->dbip, 1, (const char **)argv,
ncpu,
&gedp->ged_wdbp->wdb_initial_tree_state,
0, /* take all regions */
bev_facetize_region_end,
nmg_booltree_leaf_tess,
(genptr_t)gedp);
if (i < 0) {
bu_vls_printf(gedp->ged_result_str, "%s: error in db_walk_tree()\n", cmdname);
/* Destroy NMG */
nmg_km(bev_nmg_model);
return GED_ERROR;
}
argc--;
argv++;
if (tmp_tree && op != ' ') {
union tree *new_tree;
BU_ALLOC(new_tree, union tree);
RT_TREE_INIT(new_tree);
new_tree->tr_b.tb_regionp = REGION_NULL;
new_tree->tr_b.tb_left = tmp_tree;
new_tree->tr_b.tb_right = bev_facetize_tree;
switch (op) {
case 'u':
case 'U':
new_tree->tr_op = OP_UNION;
break;
case '-':
new_tree->tr_op = OP_SUBTRACT;
break;
case '+':
new_tree->tr_op = OP_INTERSECT;
break;
default: {
bu_vls_printf(gedp->ged_result_str, "%s: Unrecognized operator: (%c)\nAborting\n",
argv[0], op);
db_free_tree(bev_facetize_tree, &rt_uniresource);
nmg_km(bev_nmg_model);
return GED_ERROR;
}
}
tmp_tree = new_tree;
bev_facetize_tree = (union tree *)NULL;
} else if (!tmp_tree && op == ' ') {
/* just starting out */
tmp_tree = bev_facetize_tree;
bev_facetize_tree = (union tree *)NULL;
}
if (argc) {
op = *argv[0];
argc--;
argv++;
} else
op = ' ';
}
if (tmp_tree) {
/* Now, evaluate the boolean tree into ONE region */
bu_vls_printf(gedp->ged_result_str, "%s: evaluating boolean expressions\n", cmdname);
if (BU_SETJUMP) {
BU_UNSETJUMP;
bu_vls_printf(gedp->ged_result_str, "%s: WARNING: Boolean evaluation failed!!!\n", cmdname);
if (tmp_tree)
db_free_tree(tmp_tree, &rt_uniresource);
tmp_tree = (union tree *)NULL;
nmg_km(bev_nmg_model);
bev_nmg_model = (struct model *)NULL;
return GED_ERROR;
}
failed = nmg_boolean(tmp_tree, bev_nmg_model, &gedp->ged_wdbp->wdb_tol, &rt_uniresource);
BU_UNSETJUMP;
} else
failed = 1;
if (failed) {
bu_vls_printf(gedp->ged_result_str, "%s: no resulting region, aborting\n", cmdname);
if (tmp_tree)
db_free_tree(tmp_tree, &rt_uniresource);
tmp_tree = (union tree *)NULL;
nmg_km(bev_nmg_model);
bev_nmg_model = (struct model *)NULL;
return GED_ERROR;
}
/* New region remains part of this nmg "model" */
NMG_CK_REGION(tmp_tree->tr_d.td_r);
bu_vls_printf(gedp->ged_result_str, "%s: facetize %s\n", cmdname, tmp_tree->tr_d.td_name);
nmg_vmodel(bev_nmg_model);
/* Triangulate model, if requested */
if (triangulate) {
bu_vls_printf(gedp->ged_result_str, "%s: triangulating resulting object\n", cmdname);
if (BU_SETJUMP) {
BU_UNSETJUMP;
bu_vls_printf(gedp->ged_result_str, "%s: WARNING: Triangulation failed!!!\n", cmdname);
if (tmp_tree)
db_free_tree(tmp_tree, &rt_uniresource);
tmp_tree = (union tree *)NULL;
nmg_km(bev_nmg_model);
bev_nmg_model = (struct model *)NULL;
return GED_ERROR;
}
nmg_triangulate_model(bev_nmg_model, &gedp->ged_wdbp->wdb_tol);
BU_UNSETJUMP;
}
bu_vls_printf(gedp->ged_result_str, "%s: converting NMG to database format\n", cmdname);
/* Export NMG as a new solid */
RT_DB_INTERNAL_INIT(&intern);
intern.idb_major_type = DB5_MAJORTYPE_BRLCAD;
intern.idb_type = ID_NMG;
intern.idb_meth = &rt_functab[ID_NMG];
intern.idb_ptr = (genptr_t)bev_nmg_model;
bev_nmg_model = (struct model *)NULL;
GED_DB_DIRADD(gedp, dp, newname, RT_DIR_PHONY_ADDR, 0, RT_DIR_SOLID, (genptr_t)&intern.idb_type, GED_ERROR);
GED_DB_PUT_INTERNAL(gedp, dp, &intern, &rt_uniresource, GED_ERROR);
tmp_tree->tr_d.td_r = (struct nmgregion *)NULL;
/* Free boolean tree, and the regions in it. */
db_free_tree(tmp_tree, &rt_uniresource);
return GED_OK;
}
int
ged_bo(struct ged *gedp, int argc, const char *argv[])
{
int c;
unsigned int minor_type=0;
char *obj_name;
char *file_name;
int input_mode=0;
int output_mode=0;
struct rt_binunif_internal *bip;
struct rt_db_internal intern;
struct directory *dp;
const char *argv0;
static const char *usage = "{-i major_type minor_type | -o} dest source";
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);
argv0 = argv[0];
/* must be wanting help */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv0, usage);
return GED_HELP;
}
/* check that we are using a version 5 database */
if (db_version(gedp->ged_wdbp->dbip) < 5) {
bu_vls_printf(gedp->ged_result_str, "This is an older database version.\nIt does not support binary objects.Use \"dbupgrade\" to upgrade this database to the current version.\n");
return GED_ERROR;
}
bu_optind = 1; /* re-init bu_getopt() */
bu_opterr = 0; /* suppress bu_getopt()'s error message */
while ((c=bu_getopt(argc, (char * const *)argv, "iou:")) != -1) {
switch (c) {
case 'i':
input_mode = 1;
break;
case 'o':
output_mode = 1;
break;
default:
bu_vls_printf(gedp->ged_result_str, "Unrecognized option - %c", c);
return GED_ERROR;
}
}
if (input_mode + output_mode != 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv0, usage);
return GED_ERROR;
}
argc -= bu_optind;
argv += bu_optind;
if ((input_mode && argc != 4) || (output_mode && argc != 2)) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv0, usage);
return GED_ERROR;
}
if (input_mode) {
if (argv[0][0] == 'u') {
if (argv[1][1] != '\0') {
bu_vls_printf(gedp->ged_result_str, "Unrecognized minor type: %s", argv[1]);
return GED_ERROR;
}
switch ((int)argv[1][0]) {
case 'f':
minor_type = DB5_MINORTYPE_BINU_FLOAT;
break;
case 'd':
minor_type = DB5_MINORTYPE_BINU_DOUBLE;
break;
case 'c':
minor_type = DB5_MINORTYPE_BINU_8BITINT;
break;
case 's':
minor_type = DB5_MINORTYPE_BINU_16BITINT;
break;
case 'i':
minor_type = DB5_MINORTYPE_BINU_32BITINT;
break;
case 'l':
minor_type = DB5_MINORTYPE_BINU_64BITINT;
break;
case 'C':
minor_type = DB5_MINORTYPE_BINU_8BITINT_U;
break;
case 'S':
minor_type = DB5_MINORTYPE_BINU_16BITINT_U;
break;
case 'I':
minor_type = DB5_MINORTYPE_BINU_32BITINT_U;
break;
case 'L':
minor_type = DB5_MINORTYPE_BINU_64BITINT_U;
break;
default:
bu_vls_printf(gedp->ged_result_str, "Unrecognized minor type: %s", argv[1]);
return GED_ERROR;
}
} else {
bu_vls_printf(gedp->ged_result_str, "Unrecognized major type: %s", argv[0]);
return GED_ERROR;
}
/* skip past major_type and minor_type */
argc -= 2;
argv += 2;
if (minor_type == 0) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv0, usage);
return GED_ERROR;
}
obj_name = (char *)*argv;
GED_CHECK_EXISTS(gedp, obj_name, LOOKUP_QUIET, GED_ERROR);
argc--;
argv++;
file_name = (char *)*argv;
/* make a binunif of the entire file */
if (rt_mk_binunif (gedp->ged_wdbp, obj_name, file_name, minor_type, 0)) {
bu_vls_printf(gedp->ged_result_str, "Error creating %s", obj_name);
return GED_ERROR;
}
} else if (output_mode) {
FILE *fp;
file_name = (char *)*argv;
argc--;
argv++;
obj_name = (char *)*argv;
if ((dp=db_lookup(gedp->ged_wdbp->dbip, obj_name, LOOKUP_NOISY)) == RT_DIR_NULL) {
return GED_ERROR;
}
if (!(dp->d_major_type & DB5_MAJORTYPE_BINARY_MASK)) {
bu_vls_printf(gedp->ged_result_str, "%s is not a binary object", obj_name);
return GED_ERROR;
}
if (dp->d_major_type != DB5_MAJORTYPE_BINARY_UNIF) {
bu_vls_printf(gedp->ged_result_str, "source must be a uniform binary object");
return GED_ERROR;
}
fp = fopen(file_name, "w+b");
if (fp == NULL) {
bu_vls_printf(gedp->ged_result_str, "Error: cannot open file %s for writing", file_name);
return GED_ERROR;
}
if (rt_db_get_internal(&intern, dp, gedp->ged_wdbp->dbip, NULL,
&rt_uniresource) < 0) {
bu_vls_printf(gedp->ged_result_str, "Error reading %s from database", dp->d_namep);
fclose(fp);
return GED_ERROR;
}
RT_CK_DB_INTERNAL(&intern);
bip = (struct rt_binunif_internal *)intern.idb_ptr;
if (bip->count < 1) {
bu_vls_printf(gedp->ged_result_str, "%s has no contents", obj_name);
fclose(fp);
rt_db_free_internal(&intern);
return GED_ERROR;
}
if (fwrite(bip->u.int8, bip->count * db5_type_sizeof_h_binu(bip->type),
1, fp) != 1) {
bu_vls_printf(gedp->ged_result_str, "Error writing contents to file");
fclose(fp);
rt_db_free_internal(&intern);
return GED_ERROR;
}
fclose(fp);
rt_db_free_internal(&intern);
} else {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv0, usage);
return GED_ERROR;
}
return GED_OK;
}
int
ged_killtree(struct ged *gedp, int argc, const char *argv[])
{
struct directory *dp;
int i;
int c;
struct killtree_data gktd;
static const char *usage = "[-a|-f|-n] 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;
}
gktd.gedp = gedp;
gktd.killrefs = 0;
gktd.print = 0;
gktd.force = 0;
gktd.ac = 1;
gktd.top = NULL;
gktd.av = (char **)bu_calloc(1, sizeof(char *) * AV_STEP, "alloc av");
gktd.av_capacity = AV_STEP;
BU_ASSERT(gktd.ac + argc + 2 < AV_STEP); /* potential -n opts */
gktd.av[0] = "killrefs";
gktd.av[1] = (char *)0;
bu_optind = 1;
while ((c = bu_getopt(argc, (char * const *)argv, "afn")) != -1) {
switch (c) {
case 'a':
gktd.killrefs = 1;
break;
case 'n':
gktd.print = 1;
gktd.av[gktd.ac++] = bu_strdup("-n");
gktd.av[gktd.ac] = (char *)0;
break;
case 'f':
gktd.force = 1;
break;
default:
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
bu_free(gktd.av, "free av (error)");
gktd.av = NULL;
return GED_ERROR;
}
}
argc -= (bu_optind - 1);
argv += (bu_optind - 1);
/* Objects that would be killed are in the first sublist */
if (gktd.print)
bu_vls_printf(gedp->ged_result_str, "{");
for (i = 1; i < argc; i++) {
if ((dp = db_lookup(gedp->ged_wdbp->dbip, argv[i], LOOKUP_NOISY)) == RT_DIR_NULL)
continue;
/* ignore phony objects */
if (dp->d_addr == RT_DIR_PHONY_ADDR)
continue;
/* stash the what's killed so we can find refs elsewhere */
gktd.top = argv[i];
db_functree(gedp->ged_wdbp->dbip, dp,
killtree_callback, killtree_callback,
gedp->ged_wdbp->wdb_resp, (void *)&gktd);
}
/* Close the sublist of would-be killed objects. Also open the
* sublist of objects that reference the would-be killed objects.
*/
if (gktd.print)
bu_vls_printf(gedp->ged_result_str, "} {");
if (gktd.killrefs && gktd.ac > 1) {
gedp->ged_internal_call = 1;
(void)ged_killrefs(gedp, gktd.ac, (const char **)gktd.av);
gedp->ged_internal_call = 0;
for (i = 1; i < gktd.ac; i++) {
if (!gktd.print)
bu_vls_printf(gedp->ged_result_str, "Freeing %s\n", gktd.av[i]);
bu_free((void *)gktd.av[i], "killtree_data");
gktd.av[i] = NULL;
}
}
if (gktd.print)
bu_vls_printf(gedp->ged_result_str, "}");
bu_free(gktd.av, "free av");
gktd.av = NULL;
return GED_OK;
}
int
ged_move(struct ged *gedp, int argc, const char *argv[])
{
struct ged_display_list *gdlp;
struct directory *dp;
struct rt_db_internal intern;
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;
}
if ((dp = db_lookup(gedp->ged_wdbp->dbip, argv[1], LOOKUP_NOISY)) == RT_DIR_NULL)
return GED_ERROR;
if (db_lookup(gedp->ged_wdbp->dbip, argv[2], LOOKUP_QUIET) != RT_DIR_NULL) {
bu_vls_printf(gedp->ged_result_str, "%s: already exists", argv[2]);
return GED_ERROR;
}
if (rt_db_get_internal(&intern, dp, gedp->ged_wdbp->dbip, (fastf_t *)NULL, &rt_uniresource) < 0) {
bu_vls_printf(gedp->ged_result_str, "Database read error, aborting");
return GED_ERROR;
}
/* Change object name in the in-memory directory. */
if (db_rename(gedp->ged_wdbp->dbip, dp, argv[2]) < 0) {
rt_db_free_internal(&intern);
bu_vls_printf(gedp->ged_result_str, "error in db_rename to %s, aborting", argv[2]);
return GED_ERROR;
}
/* Re-write to the database. New name is applied on the way out. */
if (rt_db_put_internal(dp, gedp->ged_wdbp->dbip, &intern, &rt_uniresource) < 0) {
bu_vls_printf(gedp->ged_result_str, "Database write error, aborting");
return GED_ERROR;
}
/* Change object name if it matches the first element in the display list path. */
for (BU_LIST_FOR(gdlp, ged_display_list, gedp->ged_gdp->gd_headDisplay)) {
int first = 1;
int found = 0;
struct bu_vls new_path = BU_VLS_INIT_ZERO;
char *dupstr = strdup(bu_vls_addr(&gdlp->gdl_path));
char *tok = strtok(dupstr, "/");
while (tok) {
if (first) {
first = 0;
if (BU_STR_EQUAL(tok, argv[1])) {
found = 1;
bu_vls_printf(&new_path, "%s", argv[2]);
} else
break; /* no need to go further */
} else
bu_vls_printf(&new_path, "/%s", tok);
tok = strtok((char *)NULL, "/");
}
if (found) {
bu_vls_free(&gdlp->gdl_path);
bu_vls_printf(&gdlp->gdl_path, "%s", bu_vls_addr(&new_path));
}
free((void *)dupstr);
bu_vls_free(&new_path);
}
return GED_OK;
}
int
ged_move_all(struct ged *gedp, int argc, const char *argv[])
{
int c;
int fflag = 0;
int nflag = 0;
static const char *usage = "[-n] {-f <mapping_file>|<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 || 4 < argc) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
if (db_version(gedp->ged_wdbp->dbip) < 5 && (int)strlen(argv[2]) > NAMESIZE) {
bu_vls_printf(gedp->ged_result_str, "ERROR: name length limited to %zu characters in v4 databases\n", strlen(argv[2]));
return GED_ERROR;
}
bu_optind = 1;
while ((c = bu_getopt(argc, (char * const *)argv, "fn")) != -1) {
switch (c) {
case 'f':
fflag = 1;
break;
case 'n':
nflag = 1;
break;
default:
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
}
argc -= bu_optind;
argv += bu_optind;
if (fflag) {
if (argc != 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
return move_all_file(gedp, nflag, argv[0]);
}
if (argc != 2) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
return move_all_func(gedp, nflag, argv[0], argv[1]);
}
void
Make_brlcad_names( struct obj_info *part )
{
struct bu_vls vls = BU_VLS_INIT_ZERO;
int count=0;
char *tmp_name, *ptr;
Tcl_HashEntry *hash_entry=NULL;
if ( use_part_name_hash ) {
hash_entry = Tcl_FindHashEntry( &htbl, part->obj_name );
if ( !hash_entry ) {
/* try without any name extension */
if ( (ptr=strrchr( part->obj_name, '_' )) != NULL ) {
bu_vls_strncpy( &vls, part->obj_name, (ptr - part->obj_name) );
hash_entry = Tcl_FindHashEntry( &htbl, bu_vls_addr( &vls ) );
}
}
if ( !hash_entry ) {
/* try without any name extension */
if ( (ptr=strchr( part->obj_name, '_' )) != NULL ) {
bu_vls_strncpy( &vls, part->obj_name, (ptr - part->obj_name) );
hash_entry = Tcl_FindHashEntry( &htbl, bu_vls_addr( &vls ) );
}
}
if ( !hash_entry ) {
/* try adding "-011" */
if ( (ptr=strchr( part->obj_name, '-' )) != NULL ) {
bu_vls_strncpy( &vls, part->obj_name, (ptr - part->obj_name) );
bu_vls_strcat( &vls, "-011" );
hash_entry = Tcl_FindHashEntry( &htbl, bu_vls_addr( &vls ) );
}
}
if ( !hash_entry ) {
name_not_converted++;
}
}
bu_vls_free( &vls );
if ( hash_entry ) {
tmp_name = bu_strdup( (char *)Tcl_GetHashValue( hash_entry ) );
} else {
if ( use_part_name_hash ) {
bu_log( "\tWarning: no name found for part %s\n", part->obj_name );
}
/* make a copy of object name, then make it a legal BRL-CAD name */
if ( strlen( part->obj_name ) < 1 ) {
tmp_name = bu_strdup( "s.1" );
} else {
tmp_name = bu_strdup( part->obj_name );
ptr = tmp_name;
while ( *ptr != '\0' ) {
if ( !(isalnum( (int)*ptr ) || *ptr == '-')) {
*ptr = '_';
}
ptr++;
}
}
}
if ( part->obj_type == PART_TYPE ) {
/* find a unique solid name */
bu_vls_printf( &vls, "s.%s", tmp_name );
if ( max_name_len ) {
bu_vls_trunc( &vls, max_name_len );
}
while ( db_lookup( fd_out->dbip, bu_vls_addr( &vls ), LOOKUP_QUIET ) != RT_DIR_NULL) {
count++;
if ( max_name_len ) {
int digits = 1;
int val = 10;
while ( count >= val ) {
digits++;
val *= 10;
}
bu_vls_trunc( &vls, 0 );
bu_vls_printf( &vls, "s.%s", tmp_name );
bu_vls_trunc( &vls, max_name_len - digits - 1 );
bu_vls_printf( &vls, ".%d", count );
} else {
bu_vls_trunc( &vls, 0 );
bu_vls_printf( &vls, "s.%s.%d", tmp_name, count );
}
}
part->brlcad_solid = bu_vls_strgrab( &vls );
} else {
part->brlcad_solid = NULL;
}
/* find a unique non-primitive name */
bu_vls_printf( &vls, "%s", tmp_name );
if ( max_name_len ) {
bu_vls_trunc( &vls, max_name_len );
}
while ( db_lookup( fd_out->dbip, bu_vls_addr( &vls ), LOOKUP_QUIET) != RT_DIR_NULL ) {
count++;
if ( max_name_len ) {
int digits = 1;
int val = 10;
while ( count >= val ) {
digits++;
val *= 10;
}
bu_vls_trunc( &vls, 0 );
bu_vls_printf( &vls, "%s", tmp_name );
bu_vls_trunc( &vls, max_name_len - digits - 1 );
bu_vls_printf( &vls, ".%d", count );
} else {
bu_vls_trunc( &vls, 0 );
bu_vls_printf( &vls, "%s.%d", tmp_name, count );
}
}
part->brlcad_comb = bu_vls_strgrab( &vls );
switch ( part->obj_type ) {
case UNKNOWN_TYPE:
bu_log( "ERROR: Unknown object type for %s\n", part->obj_name );
break;
case PART_TYPE:
if ( use_part_name_hash ) {
DO_INDENT
bu_log( "part %s changed name to (%s)\n",
part->obj_name,
part->brlcad_comb );
} else {
DO_INDENT
bu_log( "part %s\n", part->brlcad_comb );
}
break;
case ASSEMBLY_TYPE:
if ( use_part_name_hash ) {
DO_INDENT
bu_log( "assembly %s changed name to (%s)\n",
part->obj_name,
part->brlcad_comb );
} else {
DO_INDENT
bu_log( "assembly %s\n", part->brlcad_comb );
}
break;
}
bu_free( tmp_name, "tmp_name" );
}
int
ged_bot(struct ged *gedp, int argc, const char *argv[])
{
struct directory *bot_dp;
struct rt_db_internal intern;
struct rt_bot_internal *bot;
const char *cmd = argv[0];
const char *sub = NULL;
const char *arg = NULL;
const char *primitive = NULL;
size_t len;
fastf_t tmp;
fastf_t propVal;
static const char *usage = "get (faces|minEdge|maxEdge|orientation|type|vertices) bot\nchull bot_in bot_out\n";
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 < 3) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", cmd, usage);
return GED_ERROR;
}
/* determine subcommand */
sub = argv[1];
len = strlen(sub);
if (bu_strncmp(sub, "get", len) == 0) {
primitive = argv[argc - 1];
}
if (bu_strncmp(sub, "chull", len) == 0) {
primitive = argv[2];
}
if (primitive == NULL) {
bu_vls_printf(gedp->ged_result_str, "%s: %s is not a known subcommand!", cmd, sub);
return GED_ERROR;
}
/* get bot */
GED_DB_LOOKUP(gedp, bot_dp, primitive, LOOKUP_NOISY, GED_ERROR & GED_QUIET);
GED_DB_GET_INTERNAL(gedp, &intern, bot_dp, bn_mat_identity, &rt_uniresource, GED_ERROR);
if (intern.idb_major_type != DB5_MAJORTYPE_BRLCAD || intern.idb_minor_type != DB5_MINORTYPE_BRLCAD_BOT) {
bu_vls_printf(gedp->ged_result_str, "%s: %s is not a BOT solid!", cmd, primitive);
return GED_ERROR;
}
bot = (struct rt_bot_internal *)intern.idb_ptr;
RT_BOT_CK_MAGIC(bot);
if (bu_strncmp(sub, "get", len) == 0) {
arg = argv[2];
propVal = rt_bot_propget(bot, arg);
/* print result string */
if (!EQUAL(propVal, -1.0)) {
tmp = (int) propVal;
/* int result */
if (EQUAL(propVal, tmp)) {
bu_vls_printf(gedp->ged_result_str, "%d", (int) propVal);
}
/* float result */
else {
bu_vls_printf(gedp->ged_result_str, "%f", propVal);
}
} else {
bu_vls_printf(gedp->ged_result_str, "%s: %s is not a valid argument!", sub, arg);
return GED_ERROR;
}
}
if (bu_strncmp(sub, "chull", len) == 0) {
int retval = 0;
int fc = 0;
int vc = 0;
point_t *vert_array;
int *faces;
unsigned char err = 0;
/* must be wanting help */
if (argc < 4) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", cmd, usage);
return GED_ERROR;
}
retval = bg_3d_chull(&faces, &fc, &vert_array, &vc, (const point_t *)bot->vertices, (int)bot->num_vertices);
if (retval != 3) return GED_ERROR;
retval = mk_bot(gedp->ged_wdbp, argv[3], RT_BOT_SOLID, RT_BOT_CCW, err, vc, fc, (fastf_t *)vert_array, faces, NULL, NULL);
if (retval) return GED_ERROR;
}
return GED_OK;
}
int
ged_make_name(struct rt_wdb *wdbp, int argc, char *argv[])
{
int status = GED_OK;
struct bu_vls obj_name;
char *cp, *tp;
static int i = 0;
int len;
static const char *usage = "template | -s [num]";
GED_CHECK_DATABASE_OPEN(wdbp, GED_ERROR);
GED_CHECK_READ_ONLY(wdbp, GED_ERROR);
/* initialize result */
bu_vls_trunc(&wdbp->wdb_result_str, 0);
wdbp->wdb_result = GED_RESULT_NULL;
wdbp->wdb_result_flags = 0;
/* must be wanting help */
if (argc == 1) {
wdbp->wdb_result_flags |= GED_RESULT_FLAGS_HELP_BIT;
bu_vls_printf(&wdbp->wdb_result_str, "Usage: %s %s", argv[0], usage);
return GED_OK;
}
switch (argc) {
case 2:
if (strcmp(argv[1], "-s") != 0)
break;
else {
i = 0;
return GED_OK;
}
case 3:
{
int new_i;
if ((strcmp(argv[1], "-s") == 0)
&& (sscanf(argv[2], "%d", &new_i) == 1)) {
i = new_i;
return GED_OK;
}
}
default:
bu_vls_printf(&wdbp->wdb_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
bu_vls_init(&obj_name);
for (cp = argv[1], len = 0; *cp != '\0'; ++cp, ++len) {
if (*cp == '@') {
if (*(cp + 1) == '@')
++cp;
else
break;
}
bu_vls_putc(&obj_name, *cp);
}
bu_vls_putc(&obj_name, '\0');
tp = (*cp == '\0') ? "" : cp + 1;
do {
bu_vls_trunc(&obj_name, len);
bu_vls_printf(&obj_name, "%d", i++);
bu_vls_strcat(&obj_name, tp);
}
while (db_lookup(wdbp->dbip, bu_vls_addr(&obj_name), LOOKUP_QUIET) != DIR_NULL);
bu_vls_printf(&wdbp->wdb_result_str, bu_vls_addr(&obj_name));
bu_vls_free(&obj_name);
return GED_OK;
}
int
diff_objs(Tcl_Interp *interp, const char *db1, const char *db2)
{
struct directory *dp1, *dp2;
char *argv[4] = {NULL, NULL, NULL, NULL};
struct bu_vls s1_tcl = BU_VLS_INIT_ZERO;
struct bu_vls s2_tcl = BU_VLS_INIT_ZERO;
struct bu_vls vls = BU_VLS_INIT_ZERO;
int has_diff = 0;
/* look at all objects in this database */
FOR_ALL_DIRECTORY_START(dp1, dbip1) {
char *str1, *str2;
Tcl_Obj *obj1, *obj2;
/* check if this object exists in the other database */
if ((dp2 = db_lookup(dbip2, dp1->d_namep, 0)) == RT_DIR_NULL) {
kill_obj(dp1->d_namep);
continue;
}
/* skip the _GLOBAL object */
if (dp1->d_major_type == DB5_MAJORTYPE_ATTRIBUTE_ONLY)
continue;
/* try to get the TCL version of this object */
bu_vls_trunc(&vls, 0);
bu_vls_printf(&vls, "%s get %s", db1, dp1->d_namep);
if (Tcl_Eval(interp, bu_vls_addr(&vls)) != TCL_OK) {
/* cannot get TCL version, use bu_external */
Tcl_ResetResult(interp);
has_diff += compare_external(dp1, dp2);
continue;
}
obj1 = Tcl_NewListObj(0, NULL);
Tcl_AppendObjToObj(obj1, Tcl_GetObjResult(interp));
bu_vls_trunc(&s1_tcl, 0);
bu_vls_trunc(&s2_tcl, 0);
bu_vls_strcpy(&s1_tcl, Tcl_GetStringResult(interp));
str1 = bu_vls_addr(&s1_tcl);
Tcl_ResetResult(interp);
/* try to get TCL version of object from the other database */
bu_vls_trunc(&vls, 0);
bu_vls_printf(&vls, "%s get %s", db2, dp1->d_namep);
if (Tcl_Eval(interp, bu_vls_addr(&vls)) != TCL_OK) {
Tcl_ResetResult(interp);
/* cannot get it, they MUST be different */
if (mode == HUMAN)
printf("Replace %s with the same object from %s\n",
dp1->d_namep, dbip2->dbi_filename);
else
printf("kill %s\n# IMPORT %s from %s\n",
dp1->d_namep, dp2->d_namep, dbip2->dbi_filename);
continue;
}
obj2 = Tcl_NewListObj(0, NULL);
Tcl_AppendObjToObj(obj2, Tcl_GetObjResult(interp));
bu_vls_strcpy(&s2_tcl, Tcl_GetStringResult(interp));
str2 = bu_vls_addr(&s2_tcl);
Tcl_ResetResult(interp);
/* got TCL versions of both */
if ((dp1->d_flags & RT_DIR_SOLID) && (dp2->d_flags & RT_DIR_SOLID)) {
/* both are solids */
has_diff += compare_tcl_solids(str1, obj1, dp1, str2, obj2);
if (pre_5_vers != 2) {
has_diff += compare_attrs(dp1, dp2);
}
continue;
}
if ((dp1->d_flags & RT_DIR_COMB) && (dp2->d_flags & RT_DIR_COMB)) {
/* both are combinations */
has_diff += compare_tcl_combs(obj1, dp1, obj2);
if (pre_5_vers != 2) {
has_diff += compare_attrs(dp1, dp2);
}
continue;
}
/* the two objects are different types */
if (!BU_STR_EQUAL(str1, str2)) {
has_diff += 1;
if (mode == HUMAN)
printf("%s:\n\twas: %s\n\tis now: %s\n\n",
dp1->d_namep, str1, str2);
else
printf("kill %s\ndb put %s %s\n",
dp1->d_namep, dp2->d_namep, str2);
}
} FOR_ALL_DIRECTORY_END;
