/*
* Returns the views eyemodel
*
* Usage:
* get_eyemodel
*
*/
int
ged_get_eyemodel(struct ged *gedp, int argc, const char *argv[])
{
quat_t quat;
vect_t eye_model;
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_DRAWABLE(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 != 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s", argv[0]);
return GED_ERROR;
}
_ged_rt_set_eye_model(gedp, eye_model);
quat_mat2quat(quat, gedp->ged_gvp->gv_rotation);
bu_vls_printf(gedp->ged_result_str, "viewsize %.15e;\n", gedp->ged_gvp->gv_size);
bu_vls_printf(gedp->ged_result_str, "orientation %.15e %.15e %.15e %.15e;\n",
V4ARGS(quat));
bu_vls_printf(gedp->ged_result_str, "eye_pt %.15e %.15e %.15e;\n",
eye_model[X], eye_model[Y], eye_model[Z]);
return GED_OK;
}
/*
* Erase all currently displayed geometry and draw the specified object(s)
*
* Usage:
* blast object(s)
*
*/
int
ged_blast(struct ged *gedp, int argc, const char *argv[])
{
static const char *usage = "object(s)";
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);
/* must be wanting help */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_HELP;
}
/* First, clear the screen */
{
const char *av[2];
av[0] = "zap";
av[1] = (char *)0;
ged_zap(gedp, 1, av);
}
/* Draw the new object(s) */
return ged_draw(gedp, argc, argv);
}
/*
* Illuminate/highlight database object
*
* Usage:
* illum [-n] obj
*
*/
int
ged_illum(struct ged *gedp, int argc, const char *argv[])
{
struct display_list *gdlp;
struct display_list *next_gdlp;
int found = 0;
int illum = 1;
static const char *usage = "[-n] obj";
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);
/* 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) {
if (argv[1][0] == '-' && argv[1][1] == 'n')
illum = 0;
else
goto bad;
--argc;
++argv;
}
if (argc != 2)
goto bad;
gdlp = BU_LIST_NEXT(display_list, gedp->ged_gdp->gd_headDisplay);
while (BU_LIST_NOT_HEAD(gdlp, gedp->ged_gdp->gd_headDisplay)) {
next_gdlp = BU_LIST_PNEXT(display_list, gdlp);
found += dl_set_illum(gdlp, argv[1], illum);
gdlp = next_gdlp;
}
if (!found) {
bu_vls_printf(gedp->ged_result_str, "illum: %s not found", argv[1]);
return GED_ERROR;
}
return GED_OK;
bad:
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
int
ged_killall(struct ged *gedp, int argc, const char *argv[])
{
int nflag;
int ret;
static const char *usage = "[-n] object(s)";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_DRAWABLE(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;
}
/* Process the -n option */
if (argc > 1 && argv[1][0] == '-' && argv[1][1] == 'n' && argv[1][2] == '\0') {
int i;
nflag = 1;
/* Objects that would be killed are in the first sublist */
bu_vls_printf(gedp->ged_result_str, "{");
for (i = 2; i < argc; i++)
bu_vls_printf(gedp->ged_result_str, "%s ", argv[i]);
bu_vls_printf(gedp->ged_result_str, "} {");
} else
nflag = 0;
gedp->ged_internal_call = 1;
if ((ret = ged_killrefs(gedp, argc, argv)) != GED_OK) {
gedp->ged_internal_call = 0;
bu_vls_printf(gedp->ged_result_str, "KILL skipped because of earlier errors.\n");
return ret;
}
gedp->ged_internal_call = 0;
if (nflag) {
/* Close the sublist of objects that reference the would-be killed objects. */
bu_vls_printf(gedp->ged_result_str, "}");
return GED_OK;
}
/* ALL references removed...now KILL the object[s] */
/* reuse argv[] */
argv[0] = "kill";
return ged_kill(gedp, argc, argv);
}
/*
* List the objects currently prepped for drawing
*
* Usage:
* who [r(eal)|p(hony)|b(oth)]
*
*/
int
ged_who(struct ged *gedp, int argc, const char *argv[])
{
struct ged_display_list *gdlp;
int skip_real, skip_phony;
static const char *usage = "[r(eal)|p(hony)|b(oth)]";
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 (2 < argc) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
skip_real = 0;
skip_phony = 1;
if (argc == 2) {
switch (argv[1][0]) {
case 'b':
skip_real = 0;
skip_phony = 0;
break;
case 'p':
skip_real = 1;
skip_phony = 0;
break;
case 'r':
skip_real = 0;
skip_phony = 1;
break;
default:
bu_vls_printf(gedp->ged_result_str, "ged_who: argument not understood\n");
return GED_ERROR;
}
}
for (BU_LIST_FOR(gdlp, ged_display_list, gedp->ged_gdp->gd_headDisplay)) {
if (gdlp->gdl_dp->d_addr == RT_DIR_PHONY_ADDR) {
if (skip_phony) continue;
} else {
if (skip_real) continue;
}
bu_vls_printf(gedp->ged_result_str, "%s ", bu_vls_addr(&gdlp->gdl_path));
}
return GED_OK;
}
/*
* 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_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 {
/*
* 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_rtwizard(struct ged *gedp, int argc, const char *argv[])
{
char **vp;
int i;
char pstring[32];
int args;
quat_t quat;
vect_t eye_model;
struct bu_vls perspective_vls = BU_VLS_INIT_ZERO;
struct bu_vls size_vls = BU_VLS_INIT_ZERO;
struct bu_vls orient_vls = BU_VLS_INIT_ZERO;
struct bu_vls eye_vls = BU_VLS_INIT_ZERO;
const char *bin;
char rt[256] = {0};
char rtscript[256] = {0};
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_DRAWABLE(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 (gedp->ged_gvp->gv_perspective > 0)
/* btclsh rtwizard --no_gui -perspective p -i db.g --viewsize size --orientation "A B C D} --eye_pt "X Y Z" */
args = argc + 1 + 1 + 1 + 2 + 2 + 2 + 2 + 2;
else
/* btclsh rtwizard --no_gui -i db.g --viewsize size --orientation "A B C D} --eye_pt "X Y Z" */
args = argc + 1 + 1 + 1 + 2 + 2 + 2 + 2;
gedp->ged_gdp->gd_rt_cmd = (char **)bu_calloc(args, sizeof(char *), "alloc gd_rt_cmd");
bin = bu_brlcad_root("bin", 1);
if (bin) {
snprintf(rt, 256, "%s/btclsh", bin);
snprintf(rtscript, 256, "%s/rtwizard", bin);
} else {
snprintf(rt, 256, "btclsh");
snprintf(rtscript, 256, "rtwizard");
}
_ged_rt_set_eye_model(gedp, eye_model);
quat_mat2quat(quat, gedp->ged_gvp->gv_rotation);
bu_vls_printf(&size_vls, "%.15e", gedp->ged_gvp->gv_size);
bu_vls_printf(&orient_vls, "%.15e %.15e %.15e %.15e", V4ARGS(quat));
bu_vls_printf(&eye_vls, "%.15e %.15e %.15e", V3ARGS(eye_model));
vp = &gedp->ged_gdp->gd_rt_cmd[0];
*vp++ = rt;
*vp++ = rtscript;
*vp++ = "--no-gui";
*vp++ = "--viewsize";
*vp++ = bu_vls_addr(&size_vls);
*vp++ = "--orientation";
*vp++ = bu_vls_addr(&orient_vls);
*vp++ = "--eye_pt";
*vp++ = bu_vls_addr(&eye_vls);
if (gedp->ged_gvp->gv_perspective > 0) {
*vp++ = "--perspective";
(void)sprintf(pstring, "%g", gedp->ged_gvp->gv_perspective);
*vp++ = pstring;
}
*vp++ = "-i";
*vp++ = gedp->ged_wdbp->dbip->dbi_filename;
/* Append all args */
for (i = 1; i < argc; i++)
*vp++ = (char *)argv[i];
*vp = 0;
/*
* Accumulate the command string.
*/
vp = &gedp->ged_gdp->gd_rt_cmd[0];
while (*vp)
bu_vls_printf(gedp->ged_result_str, "%s ", *vp++);
bu_vls_printf(gedp->ged_result_str, "\n");
gedp->ged_gdp->gd_rt_cmd_len = vp - gedp->ged_gdp->gd_rt_cmd;
(void)_ged_run_rtwizard(gedp);
bu_free(gedp->ged_gdp->gd_rt_cmd, "free gd_rt_cmd");
gedp->ged_gdp->gd_rt_cmd = NULL;
bu_vls_free(&perspective_vls);
bu_vls_free(&size_vls);
bu_vls_free(&orient_vls);
bu_vls_free(&eye_vls);
return GED_OK;
}
int
ged_brep(struct ged *gedp, int argc, const char *argv[])
{
struct bn_vlblock*vbp;
const char *solid_name;
static const char *usage = "brep <obj> [command|brepname|suffix] ";
struct directory *ndp;
struct rt_db_internal intern;
struct rt_brep_internal* bi;
struct brep_specific* bs;
struct soltab *stp;
char commtag[64];
char namebuf[64];
int i, j, real_flag, valid_command, ret;
const char *commands[] = {"info", "plot", "translate", "intersect", "csg", "u", "i", "-"};
int num_commands = (int)(sizeof(commands) / sizeof(const char *));
db_op_t op = DB_OP_NULL;
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);
/* must be wanting help */
if (argc < 2) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s\n\t%s\n", argv[0], usage);
bu_vls_printf(gedp->ged_result_str, "commands:\n");
bu_vls_printf(gedp->ged_result_str, "\tvalid - report on validity of specific BREP\n");
bu_vls_printf(gedp->ged_result_str, "\tinfo - return count information for specific BREP\n");
bu_vls_printf(gedp->ged_result_str, "\tinfo S [index] - return information for specific BREP 'surface'\n");
bu_vls_printf(gedp->ged_result_str, "\tinfo F [index] - return information for specific BREP 'face'\n");
bu_vls_printf(gedp->ged_result_str, "\tplot - plot entire BREP\n");
bu_vls_printf(gedp->ged_result_str, "\tplot S [index] - plot specific BREP 'surface'\n");
bu_vls_printf(gedp->ged_result_str, "\tplot F [index] - plot specific BREP 'face'\n");
bu_vls_printf(gedp->ged_result_str, "\tcsg - convert BREP to implicit primitive CSG tree\n");
bu_vls_printf(gedp->ged_result_str, "\ttranslate SCV index i j dx dy dz - translate a surface control vertex\n");
bu_vls_printf(gedp->ged_result_str, "\tintersect <obj2> <i> <j> [PP|PC|PS|CC|CS|SS] - BREP intersections\n");
bu_vls_printf(gedp->ged_result_str, "\tu|i|- <obj2> <output> - BREP boolean evaluations\n");
bu_vls_printf(gedp->ged_result_str, "\t[brepname] - convert the non-BREP object to BREP form\n");
bu_vls_printf(gedp->ged_result_str, "\t --no-evaluation [suffix] - convert non-BREP comb to unevaluated BREP form\n");
return GED_HELP;
}
if (argc < 2 || argc > 11) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
solid_name = argv[1];
if ((ndp = db_lookup(gedp->ged_wdbp->dbip, solid_name, LOOKUP_NOISY)) == RT_DIR_NULL) {
bu_vls_printf(gedp->ged_result_str, "Error: %s is not a solid or does not exist in database", solid_name);
return GED_ERROR;
} else {
real_flag = (ndp->d_addr == RT_DIR_PHONY_ADDR) ? 0 : 1;
}
if (!real_flag) {
/* solid doesn't exist - don't kill */
bu_vls_printf(gedp->ged_result_str, "Error: %s is not a real solid", solid_name);
return GED_OK;
}
GED_DB_GET_INTERNAL(gedp, &intern, ndp, bn_mat_identity, &rt_uniresource, GED_ERROR);
RT_CK_DB_INTERNAL(&intern);
bi = (struct rt_brep_internal*)intern.idb_ptr;
if (BU_STR_EQUAL(argv[2], "valid")) {
int valid = rt_brep_valid(&intern, gedp->ged_result_str);
return (valid) ? GED_OK : GED_ERROR;
}
if (BU_STR_EQUAL(argv[2], "intersect")) {
/* handle surface-surface intersection */
struct rt_db_internal intern2;
/* we need exactly 6 or 7 arguments */
if (argc != 6 && argc != 7) {
bu_vls_printf(gedp->ged_result_str, "There should be 6 or 7 arguments for intersection.\n");
bu_vls_printf(gedp->ged_result_str, "See the usage for help.\n");
return GED_ERROR;
}
/* get the other solid */
if ((ndp = db_lookup(gedp->ged_wdbp->dbip, argv[3], LOOKUP_NOISY)) == RT_DIR_NULL) {
bu_vls_printf(gedp->ged_result_str, "Error: %s is not a solid or does not exist in database", argv[3]);
return GED_ERROR;
} else {
real_flag = (ndp->d_addr == RT_DIR_PHONY_ADDR) ? 0 : 1;
}
if (!real_flag) {
/* solid doesn't exist - don't kill */
bu_vls_printf(gedp->ged_result_str, "Error: %s is not a real solid", argv[3]);
return GED_OK;
}
GED_DB_GET_INTERNAL(gedp, &intern2, ndp, bn_mat_identity, &rt_uniresource, GED_ERROR);
i = atoi(argv[4]);
j = atoi(argv[5]);
vbp = rt_vlblock_init();
if (argc == 6 || BU_STR_EQUAL(argv[6], "SS")) {
brep_intersect_surface_surface(&intern, &intern2, i, j, vbp);
} else if (BU_STR_EQUAL(argv[6], "PP")) {
brep_intersect_point_point(&intern, &intern2, i, j);
} else if (BU_STR_EQUAL(argv[6], "PC")) {
brep_intersect_point_curve(&intern, &intern2, i, j);
} else if (BU_STR_EQUAL(argv[6], "PS")) {
brep_intersect_point_surface(&intern, &intern2, i, j);
} else if (BU_STR_EQUAL(argv[6], "CC")) {
brep_intersect_curve_curve(&intern, &intern2, i, j);
} else if (BU_STR_EQUAL(argv[6], "CS")) {
brep_intersect_curve_surface(&intern, &intern2, i, j);
} else {
bu_vls_printf(gedp->ged_result_str, "Invalid intersection type %s.\n", argv[6]);
}
_ged_cvt_vlblock_to_solids(gedp, vbp, namebuf, 0);
bn_vlblock_free(vbp);
vbp = (struct bn_vlblock *)NULL;
rt_db_free_internal(&intern);
rt_db_free_internal(&intern2);
return GED_OK;
}
if (BU_STR_EQUAL(argv[2], "csg")) {
/* Call csg conversion routine */
struct bu_vls bname_csg;
bu_vls_init(&bname_csg);
bu_vls_sprintf(&bname_csg, "csg_%s", solid_name);
if (db_lookup(gedp->ged_wdbp->dbip, bu_vls_addr(&bname_csg), LOOKUP_QUIET) != RT_DIR_NULL) {
bu_vls_printf(gedp->ged_result_str, "%s already exists.", bu_vls_addr(&bname_csg));
bu_vls_free(&bname_csg);
return GED_OK;
}
bu_vls_free(&bname_csg);
return _ged_brep_to_csg(gedp, argv[1]);
}
/* make sure arg isn't --no-evaluate */
if (argc > 2 && argv[2][1] != '-') {
op = db_str2op(argv[2]);
}
if (op != DB_OP_NULL) {
/* test booleans on brep.
* u: union, i: intersect, -: diff, x: xor
*/
struct rt_db_internal intern2, intern_res;
struct rt_brep_internal *bip;
if (argc != 5) {
bu_vls_printf(gedp->ged_result_str, "Error: There should be exactly 5 params.\n");
return GED_ERROR;
}
/* get the other solid */
if ((ndp = db_lookup(gedp->ged_wdbp->dbip, argv[3], LOOKUP_NOISY)) == RT_DIR_NULL) {
bu_vls_printf(gedp->ged_result_str, "Error: %s is not a solid or does not exist in database", argv[3]);
return GED_ERROR;
} else {
real_flag = (ndp->d_addr == RT_DIR_PHONY_ADDR) ? 0 : 1;
}
if (!real_flag) {
/* solid doesn't exist - don't kill */
bu_vls_printf(gedp->ged_result_str, "Error: %s is not a real solid", argv[3]);
return GED_OK;
}
GED_DB_GET_INTERNAL(gedp, &intern2, ndp, bn_mat_identity, &rt_uniresource, GED_ERROR);
rt_brep_boolean(&intern_res, &intern, &intern2, op);
bip = (struct rt_brep_internal*)intern_res.idb_ptr;
mk_brep(gedp->ged_wdbp, argv[4], bip->brep);
rt_db_free_internal(&intern);
rt_db_free_internal(&intern2);
rt_db_free_internal(&intern_res);
return GED_OK;
}
if (BU_STR_EQUAL(argv[2], "selection")) {
ret = selection_command(gedp, &intern, argc, argv);
if (BU_STR_EQUAL(argv[3], "translate") && ret == 0) {
GED_DB_PUT_INTERNAL(gedp, ndp, &intern, &rt_uniresource, GED_ERROR);
}
rt_db_free_internal(&intern);
return ret;
}
if (!RT_BREP_TEST_MAGIC(bi)) {
/* The solid is not in brep form. Covert it to brep. */
struct bu_vls bname, suffix;
int no_evaluation = 0;
bu_vls_init(&bname);
bu_vls_init(&suffix);
if (argc == 2) {
/* brep obj */
bu_vls_sprintf(&bname, "%s_brep", solid_name);
bu_vls_sprintf(&suffix, "_brep");
} else if (BU_STR_EQUAL(argv[2], "--no-evaluation")) {
no_evaluation = 1;
if (argc == 3) {
/* brep obj --no-evaluation */
bu_vls_sprintf(&bname, "%s_brep", solid_name);
bu_vls_sprintf(&suffix, "_brep");
} else if (argc == 4) {
/* brep obj --no-evaluation suffix */
bu_vls_sprintf(&bname, argv[3]);
bu_vls_sprintf(&suffix, argv[3]);
}
} else {
/* brep obj brepname/suffix */
bu_vls_sprintf(&bname, argv[2]);
bu_vls_sprintf(&suffix, argv[2]);
}
if (no_evaluation && intern.idb_type == ID_COMBINATION) {
struct bu_vls bname_suffix;
bu_vls_init(&bname_suffix);
bu_vls_sprintf(&bname_suffix, "%s%s", solid_name, bu_vls_addr(&suffix));
if (db_lookup(gedp->ged_wdbp->dbip, bu_vls_addr(&bname_suffix), LOOKUP_QUIET) != RT_DIR_NULL) {
bu_vls_printf(gedp->ged_result_str, "%s already exists.", bu_vls_addr(&bname_suffix));
bu_vls_free(&bname);
bu_vls_free(&suffix);
bu_vls_free(&bname_suffix);
return GED_OK;
}
brep_conversion_comb(&intern, bu_vls_addr(&bname_suffix), bu_vls_addr(&suffix), gedp->ged_wdbp, mk_conv2mm);
bu_vls_free(&bname_suffix);
} else {
struct rt_db_internal brep_db_internal;
ON_Brep* brep;
if (db_lookup(gedp->ged_wdbp->dbip, bu_vls_addr(&bname), LOOKUP_QUIET) != RT_DIR_NULL) {
bu_vls_printf(gedp->ged_result_str, "%s already exists.", bu_vls_addr(&bname));
bu_vls_free(&bname);
bu_vls_free(&suffix);
return GED_OK;
}
ret = brep_conversion(&intern, &brep_db_internal, gedp->ged_wdbp->dbip);
if (ret == -1) {
bu_vls_printf(gedp->ged_result_str, "%s doesn't have a "
"brep-conversion function yet. Type: %s", solid_name,
intern.idb_meth->ft_label);
} else if (ret == -2) {
bu_vls_printf(gedp->ged_result_str, "%s cannot be converted "
"to brep correctly.", solid_name);
} else {
brep = ((struct rt_brep_internal *)brep_db_internal.idb_ptr)->brep;
ret = mk_brep(gedp->ged_wdbp, bu_vls_addr(&bname), brep);
if (ret == 0) {
bu_vls_printf(gedp->ged_result_str, "%s is made.", bu_vls_addr(&bname));
}
rt_db_free_internal(&brep_db_internal);
}
}
bu_vls_free(&bname);
bu_vls_free(&suffix);
rt_db_free_internal(&intern);
return GED_OK;
}
BU_ALLOC(stp, struct soltab);
if (argc == 2) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s\n", argv[0], usage);
bu_vls_printf(gedp->ged_result_str, "\t%s is in brep form, please input a command.", solid_name);
return GED_HELP;
}
valid_command = 0;
for (i = 0; i < num_commands; ++i) {
if (BU_STR_EQUAL(argv[2], commands[i])) {
valid_command = 1;
break;
}
}
if (!valid_command) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s\n", argv[0], usage);
bu_vls_printf(gedp->ged_result_str, "\t%s is in brep form, please input a command.", solid_name);
return GED_HELP;
}
if ((bs = (struct brep_specific*)stp->st_specific) == NULL) {
BU_ALLOC(bs, struct brep_specific);
bs->brep = bi->brep;
bi->brep = NULL;
stp->st_specific = (void *)bs;
}
vbp = rt_vlblock_init();
brep_command(gedp->ged_result_str, solid_name, (const struct rt_tess_tol *)&gedp->ged_wdbp->wdb_ttol, &gedp->ged_wdbp->wdb_tol, bs, bi, vbp, argc, argv, commtag);
if (BU_STR_EQUAL(argv[2], "translate")) {
bi->brep = bs->brep;
GED_DB_PUT_INTERNAL(gedp, ndp, &intern, &rt_uniresource, GED_ERROR);
}
snprintf(namebuf, 64, "%s%s_", commtag, solid_name);
_ged_cvt_vlblock_to_solids(gedp, vbp, namebuf, 0);
bn_vlblock_free(vbp);
vbp = (struct bn_vlblock *)NULL;
rt_db_free_internal(&intern);
return GED_OK;
}
int
ged_draw_guts(struct ged *gedp, int argc, const char *argv[], int kind)
{
size_t i;
int drawtrees_retval;
int flag_A_attr=0;
int flag_o_nonunique=1;
int last_opt=0;
struct bu_vls vls = BU_VLS_INIT_ZERO;
static const char *usage = "<[-R -C#/#/# -s] objects> | <-o -A attribute name/value pairs>";
/* #define DEBUG_TIMING 1 */
#ifdef DEBUG_TIMING
int64_t elapsedtime;
#endif
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);
/* must be wanting help */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_HELP;
}
#ifdef DEBUG_TIMING
elapsedtime = bu_gettime();
#endif
/* skip past cmd */
--argc;
++argv;
/* check args for "-A" (attributes) and "-o" */
for (i = 0; i < (size_t)argc; i++) {
char *ptr_A=NULL;
char *ptr_o=NULL;
char *c;
if (*argv[i] != '-') {
/* Done checking options. If our display is non-empty,
* add -R to keep current view.
*/
if (BU_LIST_NON_EMPTY(gedp->ged_gdp->gd_headDisplay)) {
bu_vls_strcat(&vls, " -R");
}
break;
}
ptr_A=strchr(argv[i], 'A');
if (ptr_A)
flag_A_attr = 1;
ptr_o=strchr(argv[i], 'o');
if (ptr_o)
flag_o_nonunique = 2;
last_opt = i;
if (!ptr_A && !ptr_o) {
bu_vls_putc(&vls, ' ');
bu_vls_strcat(&vls, argv[i]);
continue;
}
if (strlen(argv[i]) == ((size_t)1 + (ptr_A != NULL) + (ptr_o != NULL))) {
/* argv[i] is just a "-A" or "-o" */
continue;
}
/* copy args other than "-A" or "-o" */
bu_vls_putc(&vls, ' ');
c = (char *)argv[i];
while (*c != '\0') {
if (*c != 'A' && *c != 'o') {
bu_vls_putc(&vls, *c);
}
c++;
}
}
if (flag_A_attr) {
/* args are attribute name/value pairs */
struct bu_attribute_value_set avs;
int max_count=0;
int remaining_args=0;
int new_argc=0;
char **new_argv=NULL;
struct bu_ptbl *tbl;
remaining_args = argc - last_opt - 1;
if (remaining_args < 2 || remaining_args%2) {
bu_vls_printf(gedp->ged_result_str, "Error: must have even number of arguments (name/value pairs)\n");
bu_vls_free(&vls);
return GED_ERROR;
}
bu_avs_init(&avs, (argc - last_opt)/2, "ged_draw_guts avs");
i = 0;
while (i < (size_t)argc) {
if (*argv[i] == '-') {
i++;
continue;
}
/* this is a name/value pair */
if (flag_o_nonunique == 2) {
bu_avs_add_nonunique(&avs, argv[i], argv[i+1]);
} else {
bu_avs_add(&avs, argv[i], argv[i+1]);
}
i += 2;
}
tbl = db_lookup_by_attr(gedp->ged_wdbp->dbip, RT_DIR_REGION | RT_DIR_SOLID | RT_DIR_COMB, &avs, flag_o_nonunique);
bu_avs_free(&avs);
if (!tbl) {
bu_log("Error: db_lookup_by_attr() failed!!\n");
bu_vls_free(&vls);
return TCL_ERROR;
}
if (BU_PTBL_LEN(tbl) < 1) {
/* nothing matched, just return */
bu_vls_free(&vls);
return TCL_OK;
}
for (i = 0; i < BU_PTBL_LEN(tbl); i++) {
struct directory *dp;
dp = (struct directory *)BU_PTBL_GET(tbl, i);
bu_vls_putc(&vls, ' ');
bu_vls_strcat(&vls, dp->d_namep);
}
max_count = BU_PTBL_LEN(tbl) + last_opt + 1;
bu_ptbl_free(tbl);
bu_free((char *)tbl, "ged_draw_guts ptbl");
new_argv = (char **)bu_calloc(max_count+1, sizeof(char *), "ged_draw_guts new_argv");
new_argc = bu_argv_from_string(new_argv, max_count, bu_vls_addr(&vls));
/* First, delete any mention of these objects.
* Silently skip any leading options (which start with minus signs).
*/
for (i = 0; i < (size_t)new_argc; ++i) {
/* Skip any options */
if (new_argv[i][0] == '-') {
/* If this option requires an argument which was
* provided separately (e.g. '-C 0/255/0' instead of
* '-C0/255/0'), skip the argument too.
*/
if (strlen(argv[i]) == 2 && strchr("mxCP", argv[i][1])) {
i++;
}
continue;
}
dl_erasePathFromDisplay(gedp->ged_gdp->gd_headDisplay, gedp->ged_wdbp->dbip, gedp->ged_free_vlist_callback, new_argv[i], 0, gedp->freesolid);
}
drawtrees_retval = _ged_drawtrees(gedp, new_argc, (const char **)new_argv, kind, (struct _ged_client_data *)0);
bu_vls_free(&vls);
bu_free((char *)new_argv, "ged_draw_guts new_argv");
if (drawtrees_retval) {
return GED_ERROR;
}
} else {
int empty_display;
bu_vls_free(&vls);
empty_display = 1;
if (BU_LIST_NON_EMPTY(gedp->ged_gdp->gd_headDisplay)) {
empty_display = 0;
}
/* First, delete any mention of these objects.
* Silently skip any leading options (which start with minus signs).
*/
for (i = 0; i < (size_t)argc; ++i) {
/* Skip any options */
if (argv[i][0] == '-') {
/* If this option requires an argument which was
* provided separately (e.g. '-C 0/255/0' instead of
* '-C0/255/0'), skip the argument too.
*/
if (strlen(argv[i]) == 2 && strchr("mxCP", argv[i][1])) {
i++;
}
continue;
}
dl_erasePathFromDisplay(gedp->ged_gdp->gd_headDisplay, gedp->ged_wdbp->dbip, gedp->ged_free_vlist_callback, argv[i], 0, gedp->freesolid);
}
/* if our display is non-empty add -R to keep current view */
if (!empty_display) {
int new_argc;
char **new_argv;
new_argc = argc + 1;
new_argv = (char **)bu_malloc(new_argc * sizeof(char *), "ged_draw_guts new_argv");
new_argv[0] = bu_strdup("-R");
for (i = 0; i < (size_t)argc; ++i) {
new_argv[i + 1] = bu_strdup(argv[i]);
}
drawtrees_retval = _ged_drawtrees(gedp, new_argc, (const char **)new_argv, kind, (struct _ged_client_data *)0);
for (i = 0; i < (size_t)new_argc; ++i) {
bu_free(new_argv[i], "ged_draw_guts new_argv[i] - bu_strdup(argv[i])");
}
bu_free(new_argv, "ged_draw_guts new_argv");
} else {
drawtrees_retval = _ged_drawtrees(gedp, argc, argv, kind, (struct _ged_client_data *)0);
}
if (drawtrees_retval) {
return GED_ERROR;
}
}
#ifdef DEBUG_TIMING
elapsedtime = bu_gettime() - elapsedtime;
{
int seconds = elapsedtime / 1000000;
int minutes = seconds / 60;
int hours = minutes / 60;
minutes = minutes % 60;
seconds = seconds %60;
bu_vls_printf(gedp->ged_result_str, "Elapsed time: %02d:%02d:%02d\n", hours, minutes, seconds);
}
#endif
return GED_OK;
}
/* !!! FIXME: this command should not be directly utilizing LIBDM or
* LIBFB as this breaks library encapsulation. Generic functionality
* should be moved out of LIBDM into LIBICV, or be handled by the
* application logic calling this routine.
*/
int
ged_screen_grab(struct ged *gedp, int argc, const char *argv[])
{
int i;
int width = 0;
int height = 0;
int bytes_per_pixel = 0;
int bytes_per_line = 0;
static const char *usage = "image_name.ext";
unsigned char **rows = NULL;
unsigned char *idata = NULL;
struct icv_image *bif = NULL; /**< icv image container for saving images */
if (gedp->ged_dmp_is_null) {
bu_vls_printf(gedp->ged_result_str, "Bad display pointer.");
return GED_ERROR;
}
if (gedp->ged_dm_get_display_image == NULL) {
bu_vls_printf(gedp->ged_result_str, "Bad display function pointer.");
return GED_ERROR;
}
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_VIEW(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);
/* 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;
}
width = gedp->ged_dm_width;
height = gedp->ged_dm_height;
if (width <= 0 || height <= 0) {
bu_vls_printf(gedp->ged_result_str, "%s: invalid screen dimensions.", argv[1]);
return GED_ERROR;
}
bytes_per_pixel = 3;
bytes_per_line = width * bytes_per_pixel;
/* create image file */
if ((bif = icv_create(width, height, ICV_COLOR_SPACE_RGB)) == NULL) {
bu_vls_printf(gedp->ged_result_str, "%s: could not create icv_image write structure.", argv[1]);
return GED_ERROR;
}
rows = (unsigned char **)bu_calloc(height, sizeof(unsigned char *), "rows");
gedp->ged_dm_get_display_image(gedp, &idata);
for (i = 0; i < height; ++i) {
rows[i] = (unsigned char *)(idata + ((height-i-1)*bytes_per_line));
/* TODO : Add double type data to maintain resolution */
icv_writeline(bif, i, rows[i], ICV_DATA_UCHAR);
}
if (bif != NULL) {
icv_write(bif, argv[1], ICV_IMAGE_AUTO);
icv_destroy(bif);
bif = NULL;
}
bu_free(rows, "rows");
bu_free(idata, "image data");
return GED_OK;
}
int
ged_remove(struct ged *gedp, int argc, const char *argv[])
{
struct directory *dp;
int i;
int num_deleted;
struct rt_db_internal intern;
struct rt_comb_internal *comb;
int ret;
static const char *usage = "comb object(s)";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_DRAWABLE(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 ((dp->d_flags & RT_DIR_COMB) == 0) {
bu_vls_printf(gedp->ged_result_str, "rm: %s is not a combination", dp->d_namep);
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;
}
comb = (struct rt_comb_internal *)intern.idb_ptr;
RT_CK_COMB(comb);
/* Process each argument */
num_deleted = 0;
ret = TCL_OK;
for (i = 2; i < argc; i++) {
if (db_tree_del_dbleaf(&(comb->tree), argv[i], &rt_uniresource, 0) < 0) {
bu_vls_printf(gedp->ged_result_str, "ERROR: Failure deleting %s/%s\n", dp->d_namep, argv[i]);
ret = GED_ERROR;
} else {
struct bu_vls path = BU_VLS_INIT_ZERO;
bu_vls_printf(&path, "%s/%s", dp->d_namep, argv[i]);
_ged_eraseAllPathsFromDisplay(gedp, bu_vls_addr(&path), 0);
bu_vls_free(&path);
bu_vls_printf(gedp->ged_result_str, "deleted %s/%s\n", dp->d_namep, argv[i]);
num_deleted++;
}
}
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;
}
return ret;
}
