/*
* 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;
}
int
ged_echo(struct ged *gedp, int argc, const char *argv[])
{
int i;
static const char *usage = "args";
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;
}
for (i = 1; i < argc; i++) {
bu_vls_printf(gedp->ged_result_str, "%s%s", i == 1 ? "" : " ", argv[i]);
}
bu_vls_printf(gedp->ged_result_str, "\n");
return GED_OK;
}
/*
* Validate points data file unit string and output conversion factor
* to millimeters. If string is not a standard units identifier, the
* function assumes a custom conversion factor was specified. A valid
* null terminated string is expected as input. The function returns
* GED_ERROR if the unit string is invalid or if null pointers were
* passed to the function.
*/
int
str2mm(const char *units_string, double *conv_factor, struct bu_vls *ged_result_str)
{
struct bu_vls str = BU_VLS_INIT_ZERO;
double tmp_value = 0.0;
char *endp = (char *)NULL;
int ret = GED_OK;
if ((units_string == (char *)NULL) || (conv_factor == (double *)NULL)) {
bu_vls_printf(ged_result_str, "NULL pointer(s) passed to function 'str2mm'.\n");
ret = GED_ERROR;
} else {
bu_vls_strcat(&str, units_string);
bu_vls_trimspace(&str);
tmp_value = strtod(bu_vls_addr(&str), &endp);
if ((endp != bu_vls_addr(&str)) && (*endp == '\0')) {
/* convert to double success */
*conv_factor = tmp_value;
} else if ((tmp_value = bu_mm_value(bu_vls_addr(&str))) > 0.0) {
*conv_factor = tmp_value;
} else {
bu_vls_printf(ged_result_str, "Invalid units string '%s'\n", units_string);
ret = GED_ERROR;
}
}
bu_vls_free(&str);
return ret;
}
int
ged_form(struct ged *gedp, int argc, const char *argv[])
{
const struct rt_functab *ftp;
static const char *usage = "type";
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 ((ftp = rt_get_functab_by_label(argv[1])) == NULL) {
bu_vls_printf(gedp->ged_result_str, "There is no geometric object type \"%s\".", argv[1]);
return GED_ERROR;
}
if (!ftp->ft_form) {
return GED_ERROR;
}
return ftp->ft_form(gedp->ged_result_str, ftp);
}
/*
* P R _ W A I T _ S T A T U S
*
* Interpret the status return of a wait() system call,
* for the edification of the watching luser.
* Warning: This may be somewhat system specific, most especially
* on non-UNIX machines.
*/
static void
pr_wait_status(Tcl_Interp *interp,
int status)
{
int sig = status & 0x7f;
int core = status & 0x80;
int ret = status >> 8;
struct bu_vls tmp_vls = BU_VLS_INIT_ZERO;
if (status == 0) {
Tcl_AppendResult(interp, "Normal exit\n", (char *)NULL);
return;
}
bu_vls_printf(&tmp_vls, "Abnormal exit x%x", status);
if (core)
bu_vls_printf(&tmp_vls, ", core dumped");
if (sig)
bu_vls_printf(&tmp_vls, ", terminating signal = %d", sig);
else
bu_vls_printf(&tmp_vls, ", return (exit) code = %d", ret);
Tcl_AppendResult(interp, bu_vls_addr(&tmp_vls), "\n", (char *)NULL);
bu_vls_free(&tmp_vls);
}
static const char *
save_comb(struct ged *gedp, struct directory *dpold)
{
/* Save a combination under a temporary name */
struct directory *dp;
struct rt_db_internal intern;
/* Make a new name */
const char *name = mktemp_comb(gedp, tmpcomb);
if (rt_db_get_internal(&intern, dpold, gedp->ged_wdbp->dbip, (fastf_t *)NULL, &rt_uniresource) < 0) {
bu_vls_printf(gedp->ged_result_str, "save_comb: Database read error, aborting\n");
return NULL;
}
if ((dp = db_diradd(gedp->ged_wdbp->dbip, name, RT_DIR_PHONY_ADDR, 0, dpold->d_flags, (genptr_t)&intern.idb_type)) == RT_DIR_NULL) {
bu_vls_printf(gedp->ged_result_str, "save_comb: Cannot save copy of %s, no changed made\n", dpold->d_namep);
return NULL;
}
if (rt_db_put_internal(dp, gedp->ged_wdbp->dbip, &intern, &rt_uniresource) < 0) {
bu_vls_printf(gedp->ged_result_str, "save_comb: Cannot save copy of %s, no changed made\n", dpold->d_namep);
return NULL;
}
return name;
}
/*
*
* Usage:
* procname getcursor
*/
HIDDEN int
fbo_getcursor_tcl(ClientData clientData, Tcl_Interp *interp, int argc, char **argv)
{
struct fb_obj *fbop = (struct fb_obj *)clientData;
int status;
int mode;
int x, y;
struct bu_vls vls;
if (argc != 2) {
bu_vls_init(&vls);
bu_vls_printf(&vls, "helplib fb_getcursor");
Tcl_Eval(interp, bu_vls_addr(&vls));
bu_vls_free(&vls);
return TCL_ERROR;
}
status = fb_getcursor(fbop->fbo_fbs.fbs_fbp, &mode, &x, &y);
if (status == 0) {
bu_vls_init(&vls);
bu_vls_printf(&vls, "%d %d %d", mode, x, y);
Tcl_AppendResult(interp, bu_vls_addr(&vls), (char *)NULL);
bu_vls_free(&vls);
return TCL_OK;
}
return TCL_ERROR;
}
int
ged_zoom(struct ged *gedp, int argc, const char *argv[])
{
int ret;
double sf = 1.0;
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);
/* must be wanting help */
if (argc != 2) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s scale_factor", argv[0]);
return (argc == 1) ? GED_HELP : GED_ERROR;
}
/* get the scale factor */
ret = sscanf(argv[1], "%lf", &sf);
if (ret != 1 || sf < SMALL_FASTF || sf > INFINITY) {
bu_vls_printf(gedp->ged_result_str, "ERROR: bad scale factor [%s]", argv[1]);
return GED_ERROR;
}
return zoom(gedp, sf);
}
/* FIXME: not verified in the least bit */
static int
create_cyl(point_line_t **plta, int count) {
int i;
point_line_t *plt = NULL;
const char *result;
struct bu_vls vls = BU_VLS_INIT_ZERO;
struct bu_vls vls2 = BU_VLS_INIT_ZERO;
for (i = 0; i < count; i++) {
plt = &(*plta)[i];
if (plt && plt->type)
bu_vls_printf(&vls, "{ %f %f %f } ", plt->val[X], plt->val[Y], plt->val[Z]);
}
bu_vls_printf(&vls2, "cylinder { %s }", bu_vls_addr(&vls));
#if PRINT_SCRIPT
fprintf(stderr, "%s\n", bu_vls_addr(&vls2));
#endif
#if RUN_SCRIPT
Tcl_Eval(twerp, bu_vls_addr(&vls2));
result = Tcl_GetStringResult(twerp);
if (result && result[0] != '\0')
bu_log("create_cyl failure: %s\n", result);
else
bu_log("create_cyl created\n");
#endif
return 1;
}
/* FIXME: not verified in the least bit */
static int
create_cyl(point_line_t **plta, int count) {
int i;
point_line_t *plt = NULL;
struct bu_vls vls;
struct bu_vls vls2;
bu_vls_init(&vls);
bu_vls_init(&vls2);
for (i = 0; i < count; i++) {
plt = &(*plta)[i];
if (plt && plt->type)
bu_vls_printf(&vls, "{ %f %f %f } ", plt->val[X], plt->val[Y], plt->val[Z]);
}
bu_vls_printf(&vls2, "cylinder { %S }", &vls);
#if PRINT_SCRIPT
fprintf(stderr, "%s\n", bu_vls_addr(&vls2));
#endif
#if RUN_SCRIPT
Tcl_Eval(twerp, bu_vls_addr(&vls2));
if (twerp->result[0] != '\0')
bu_log("create_cyl failure: %s\n", twerp->result);
else
bu_log("create_cyl created\n");
#endif
return 1;
}
int
ged_debuglib(struct ged *gedp, int argc, const char *argv[])
{
static const char *usage = "[hex_code]";
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);
if (argc > 2) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
/* get librt's debug bit vector */
if (argc == 1) {
bu_vls_printb(gedp->ged_result_str, "Possible flags", 0xffffffffL, DEBUG_FORMAT);
bu_vls_printf(gedp->ged_result_str, "\n");
} else {
/* set librt's debug bit vector */
if (sscanf(argv[1], "%x", (unsigned int *)&rt_g.debug) != 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
if (RT_G_DEBUG) bu_debug |= BU_DEBUG_COREDUMP;
}
bu_vls_printb(gedp->ged_result_str, "librt RT_G_DEBUG", RT_G_DEBUG, DEBUG_FORMAT);
bu_vls_printf(gedp->ged_result_str, "\n");
return GED_OK;
}
/*
* Supports for the 'keep' method.
* Write each node encountered exactly once.
*/
HIDDEN void
node_write(struct db_i *dbip, struct directory *dp, void *ptr)
{
struct keep_node_data *kndp = (struct keep_node_data *)ptr;
struct rt_db_internal intern;
RT_CK_WDB(kndp->wdbp);
if (dp->d_nref++ > 0)
return; /* already written */
if (rt_db_get_internal(&intern, dp, dbip, NULL, &rt_uniresource) < 0) {
bu_vls_printf(kndp->gedp->ged_result_str, "Database read error, aborting\n");
return;
}
if (dp->d_major_type == DB5_MAJORTYPE_BRLCAD && dp->d_minor_type == DB5_MINORTYPE_BRLCAD_EXTRUDE) {
/* if this is an extrusion, keep the referenced sketch */
struct rt_extrude_internal *extr;
struct directory *dp2;
extr = (struct rt_extrude_internal *)intern.idb_ptr;
RT_EXTRUDE_CK_MAGIC(extr);
if ((dp2 = db_lookup(dbip, extr->sketch_name, LOOKUP_QUIET)) != RT_DIR_NULL) {
node_write(dbip, dp2, ptr);
}
} else if (dp->d_major_type == DB5_MAJORTYPE_BRLCAD && dp->d_minor_type == DB5_MINORTYPE_BRLCAD_REVOLVE) {
/* if this is a revolve, keep the referenced sketch */
struct rt_revolve_internal *rev;
struct directory *dp2;
rev = (struct rt_revolve_internal *)intern.idb_ptr;
RT_REVOLVE_CK_MAGIC(rev);
if ((dp2 = db_lookup(dbip, bu_vls_addr(&rev->sketch_name), LOOKUP_QUIET)) != RT_DIR_NULL) {
node_write(dbip, dp2, ptr);
}
} else if (dp->d_major_type == DB5_MAJORTYPE_BRLCAD && dp->d_minor_type == DB5_MINORTYPE_BRLCAD_DSP) {
/* if this is a DSP, keep the referenced binary object too */
struct rt_dsp_internal *dsp;
struct directory *dp2;
dsp = (struct rt_dsp_internal *)intern.idb_ptr;
RT_DSP_CK_MAGIC(dsp);
if (dsp->dsp_datasrc == RT_DSP_SRC_OBJ) {
/* need to keep this object */
if ((dp2 = db_lookup(dbip, bu_vls_addr(&dsp->dsp_name), LOOKUP_QUIET)) != RT_DIR_NULL) {
node_write(dbip, dp2, ptr);
}
}
}
if (wdb_put_internal(kndp->wdbp, dp->d_namep, &intern, 1.0) < 0) {
bu_vls_printf(kndp->gedp->ged_result_str, "Database write error, aborting\n");
return;
}
}
/* The code below starts the part that still needs reworking for the
* new geometry based tokens/logic */
static int
primary(enum token n, struct exists_data *ed)
{
enum token nn;
int res;
if (n == EOI)
return 0; /* missing expression */
if (n == LPAREN) {
ed->t_wp_op = NULL;
if ((nn = t_lex(*++(ed->t_wp), ed)) == RPAREN)
return 0; /* missing expression */
res = oexpr(nn, ed);
if (t_lex(*++(ed->t_wp), ed) != RPAREN) {
bu_vls_printf(ed->message , "closing paren expected");
return 0;
}
return res;
}
if (ed->t_wp_op && ed->t_wp_op->op_type == UNOP) {
/* unary expression */
if (!ed->no_op) {
if (*++(ed->t_wp) == NULL) {
bu_vls_printf(ed->message , "argument expected");
return 0;
}
}
switch (n) {
case OCOMB:
bu_log("comb case");
/*return is_comb();*/
case OEXIST:
return db_object_exists(ed);
/*return db_lookup();*/
case ONULL:
bu_log("null case");
/*return is_null();*/
case ONNULL:
/* default case */
return db_object_exists_and_non_null(ed);
case OPRIM:
bu_log("primitive case");
/*return is_prim();*/
case OBVOL:
bu_log("bounding volume case");
/*return has_vol();*/
default:
/* not reached */
return 0;
}
}
if (t_lex(ed->t_wp[1], ed), ed->t_wp_op && ed->t_wp_op->op_type == BINOP) {
return binop(ed);
}
return 0;
}
static int
count_nodes(struct ged *gedp, char *line)
{
char *ptr;
char *name;
char relation;
int node_count=0;
/* sanity */
if (line == NULL)
return 0;
ptr = strtok(line, _delims);
while (ptr) {
/* First non-white is the relation operator */
relation = (*ptr);
if (relation != '+' && relation != 'u' && relation != '-') {
bu_vls_printf(gedp->ged_result_str, " %c is not a legal operator\n", relation);
return -1;
}
/* Next must be the member name */
name = strtok((char *)NULL, _delims);
if (name == NULL) {
bu_vls_printf(gedp->ged_result_str, " operand name missing\n");
return -1;
}
ptr = strtok((char *)NULL, _delims);
/*
* If this token is not a boolean operator, then it must be the start
* of a matrix which we will skip.
*/
if (ptr && !((*ptr == 'u' || *ptr == '-' || *ptr == '+') &&
*(ptr+1) == '\0')) {
int k;
/* skip past matrix, k = 1 because we already have the first value */
for (k = 1; k < 16; k++) {
ptr = strtok((char *)NULL, _delims);
if (!ptr) {
bu_vls_printf(gedp->ged_result_str, "expecting a matrix\n");
return -1;
}
}
/* get the next relational operator on the current line */
ptr = strtok((char *)NULL, _delims);
}
node_count++;
}
return node_count;
}
void
rt_pr_pt_vls(struct bu_vls *v, const struct rt_i *rtip, register const struct partition *pp)
{
register const struct soltab *stp;
register struct seg **segpp;
RT_CHECK_RTI(rtip);
RT_CHECK_PT(pp);
BU_CK_VLS(v);
bu_log_indent_vls(v);
bu_vls_printf(v, "%p: PT ", (void *)pp);
stp = pp->pt_inseg->seg_stp;
bu_vls_printf(v, "%s (%s#%ld) ",
stp->st_dp->d_namep,
OBJ[stp->st_id].ft_name+3,
stp->st_bit);
stp = pp->pt_outseg->seg_stp;
bu_vls_printf(v, "%s (%s#%ld) ",
stp->st_dp->d_namep,
OBJ[stp->st_id].ft_name+3,
stp->st_bit);
bu_vls_printf(v, "(%g, %g)",
pp->pt_inhit->hit_dist, pp->pt_outhit->hit_dist);
if (pp->pt_inflip) bu_vls_strcat(v, " Iflip");
if (pp->pt_outflip) bu_vls_strcat(v, " Oflip");
bu_vls_strcat(v, "\n");
rt_pr_hit_vls(v, " In", pp->pt_inhit);
rt_pr_hit_vls(v, " Out", pp->pt_outhit);
bu_log_indent_vls(v);
bu_vls_strcat(v, " Primitives: ");
for (BU_PTBL_FOR(segpp, (struct seg **), &pp->pt_seglist)) {
stp = (*segpp)->seg_stp;
RT_CK_SOLTAB(stp);
bu_vls_strcat(v, stp->st_dp->d_namep);
bu_vls_strcat(v, ", ");
}
bu_vls_strcat(v, "\n");
bu_log_indent_vls(v);
bu_vls_strcat(v, " Untrimmed Segments spanning this interval:\n");
bu_log_indent_delta(4);
for (BU_PTBL_FOR(segpp, (struct seg **), &pp->pt_seglist)) {
RT_CK_SEG(*segpp);
rt_pr_seg_vls(v, *segpp);
}
bu_log_indent_delta(-4);
if (pp->pt_regionp) {
RT_CK_REGION(pp->pt_regionp);
bu_log_indent_vls(v);
bu_vls_printf(v, " Region: %s\n", pp->pt_regionp->reg_name);
}
}
/*
* 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
compare_attrs(struct directory *dp1, struct directory *dp2)
{
struct bu_vls vls = BU_VLS_INIT_ZERO;
Tcl_Obj *obj1, *obj2;
int different = 0;
if (db_version(dbip1) > 4) {
bu_vls_printf(&vls, "_db1 attr get %s", dp1->d_namep);
if (Tcl_Eval(INTERP, bu_vls_addr(&vls)) != TCL_OK) {
fprintf(stderr, "Cannot get attributes for %s\n", dp1->d_namep);
fprintf(stderr, "%s\n", Tcl_GetStringResult(INTERP));
bu_exit(1, NULL);
}
obj1 = Tcl_DuplicateObj(Tcl_GetObjResult(INTERP));
Tcl_ResetResult(INTERP);
if (dp1->d_flags & RT_DIR_REGION && verify_region_attribs) {
verify_region_attrs(dp1, dbip1, obj1);
}
} else {
obj1 = Tcl_NewObj();
}
if (db_version(dbip2) > 4) {
bu_vls_trunc(&vls, 0);
bu_vls_printf(&vls, "_db2 attr get %s", dp1->d_namep);
if (Tcl_Eval(INTERP, bu_vls_addr(&vls)) != TCL_OK) {
fprintf(stderr, "Cannot get attributes for %s\n", dp1->d_namep);
fprintf(stderr, "%s\n", Tcl_GetStringResult(INTERP));
bu_exit(1, NULL);
}
obj2 = Tcl_DuplicateObj(Tcl_GetObjResult(INTERP));
Tcl_ResetResult(INTERP);
if (dp1->d_flags & RT_DIR_REGION && verify_region_attribs) {
verify_region_attrs(dp2, dbip2, obj2);
}
} else {
obj2 = Tcl_NewObj();
}
if ((dp1->d_flags & RT_DIR_REGION) && (dp2->d_flags & RT_DIR_REGION)) {
/* don't complain about "region" attributes */
remove_region_attrs(obj1);
remove_region_attrs(obj2);
}
bu_vls_trunc(&vls, 0);
different = do_compare(ATTRS, &vls, obj1, obj2, dp1->d_namep);
printf("%s", bu_vls_addr(&vls));
bu_vls_free(&vls);
return different;
}
HIDDEN void
constraint_usage(struct bu_vls *vp, const char *argv0)
{
static const char *usage1 = "set constraint_name [expression]";
static const char *usage2 = "{get|show|eval} constraint_name1 [constraint_name2 ...]";
bu_vls_printf(vp, "Usage: %s %s\n", argv0, usage1);
bu_vls_printf(vp, " or %s %s\n", argv0, usage2);
bu_vls_printf(vp, " or %s help [command]\n", argv0);
}
/**
* used for db put/asc2g
*/
int
rt_metaball_adjust(struct bu_vls *logstr, struct rt_db_internal *intern, int argc, const char **argv)
{
struct rt_metaball_internal *mb;
const char *pts;
const char *pend;
double thresh;
if (argc != 3) {
bu_vls_printf(logstr, "Invalid number of arguments: %d\n", argc);
return BRLCAD_ERROR;
}
RT_CK_DB_INTERNAL(intern);
mb = (struct rt_metaball_internal *)intern->idb_ptr;
RT_METABALL_CK_MAGIC(mb);
if ( strlen(*argv) != 1 || (**argv < '0' || **argv > '2') ) {
bu_vls_printf(logstr, "Invalid method type, must be one of 0, 1, or 2.");
return BRLCAD_ERROR;
}
mb->method = *argv[0] - '0';
sscanf(argv[1], "%lG", &thresh);
mb->threshold = thresh;
BU_LIST_INIT(&mb->metaball_ctrl_head);
pts = argv[2];
pend = pts + strlen(pts);
while (1) {
int len;
double xyz[3];
double fldstr, goo;
point_t loc;
const point_t *locp = (const point_t *)&loc;
while ( pts < pend && *pts != '{' ) ++pts;
if (pts >= pend) break;
len = sscanf(pts, "{%lG %lG %lG %lG %lG}", &xyz[0], &xyz[1], &xyz[2], &fldstr, &goo);
VMOVE(loc, xyz);
if (len == EOF) break;
if (len != 5) {
bu_vls_printf(logstr, "Failed to parse point information: \"%s\"", pts);
return BRLCAD_ERROR;
}
pts++;
if (rt_metaball_add_point (mb, locp, fldstr, goo)) {
bu_vls_printf(logstr, "Failure adding point: {%f %f %f %f %f}", V3ARGS(loc), fldstr, goo);
return BRLCAD_ERROR;
}
}
return BRLCAD_OK;
}
void
rt_pr_fallback_angle(struct bu_vls *str, const char *prefix, const double *angles)
{
BU_CK_VLS(str);
bu_vls_printf(str, "%s direction cosines=(%1.f, %1.f, %1.f)\n",
prefix, INTCLAMP(angles[0]), INTCLAMP(angles[1]), INTCLAMP(angles[2]));
bu_vls_printf(str, "%s rotation angle=%1.f, fallback angle=%1.f\n",
prefix, INTCLAMP(angles[3]), INTCLAMP(angles[4]));
}
int
ged_get_bot_edges(struct ged *gedp, int argc, const char *argv[])
{
static const char *usage = "bot";
struct rt_db_internal intern;
struct rt_bot_internal *botip;
mat_t mat;
size_t edge_count;
size_t *edge_list;
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 (wdb_import_from_path2(gedp->ged_result_str, &intern, argv[1], gedp->ged_wdbp, mat) == GED_ERROR) {
bu_vls_printf(gedp->ged_result_str, "%s: failed to find %s", argv[0], argv[1]);
return 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, "Object is not a BOT");
rt_db_free_internal(&intern);
return GED_ERROR;
}
botip = (struct rt_bot_internal *)intern.idb_ptr;
if ((edge_count = rt_bot_get_edge_list(botip, &edge_list)) > 0) {
size_t i;
for (i = 0; i < edge_count; i++)
bu_vls_printf(gedp->ged_result_str, "{%zu %zu} ", edge_list[i*2], edge_list[i*2+1]);
bu_free(edge_list, "bot edge list");
}
rt_db_free_internal(&intern);
return GED_OK;
}
/*
* 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;
}
/*
* Validate 'point file data format string', determine and output the
* point-cloud type. A valid null terminated string is expected as
* input. The function returns GED_ERROR if the format string is
* invalid or if null pointers were passed to the function.
*/
int
str2type(const char *format_string, rt_pnt_type *pnt_type, struct bu_vls *ged_result_str)
{
struct bu_vls str = BU_VLS_INIT_ZERO;
char *temp_string = (char *)NULL;
size_t idx = 0;
size_t format_string_length = 0;
int ret = GED_OK;
if ((format_string == (char *)NULL) || (pnt_type == (rt_pnt_type *)NULL)) {
bu_vls_printf(ged_result_str, "NULL pointer(s) passed to function 'str2type'.\n");
ret = GED_ERROR;
} else {
format_string_length = strlen(format_string);
/* remove any '?' from format string before testing for point-cloud type */
for (idx = 0 ; idx < format_string_length ; idx++) {
if (format_string[idx] != '?') {
bu_vls_putc(&str, format_string[idx]);
}
}
bu_vls_trimspace(&str);
temp_string = bu_vls_addr(&str);
bu_sort(temp_string, strlen(temp_string), sizeof(char), (int (*)(const void *a, const void *b, void *arg))compare_char, NULL);
if (BU_STR_EQUAL(temp_string, "xyz")) {
*pnt_type = RT_PNT_TYPE_PNT;
} else if (BU_STR_EQUAL(temp_string, "bgrxyz")) {
*pnt_type = RT_PNT_TYPE_COL;
} else if (BU_STR_EQUAL(temp_string, "sxyz")) {
*pnt_type = RT_PNT_TYPE_SCA;
} else if (BU_STR_EQUAL(temp_string, "ijkxyz")) {
*pnt_type = RT_PNT_TYPE_NRM;
} else if (BU_STR_EQUAL(temp_string, "bgrsxyz")) {
*pnt_type = RT_PNT_TYPE_COL_SCA;
} else if (BU_STR_EQUAL(temp_string, "bgijkrxyz")) {
*pnt_type = RT_PNT_TYPE_COL_NRM;
} else if (BU_STR_EQUAL(temp_string, "ijksxyz")) {
*pnt_type = RT_PNT_TYPE_SCA_NRM;
} else if (BU_STR_EQUAL(temp_string, "bgijkrsxyz")) {
*pnt_type = RT_PNT_TYPE_COL_SCA_NRM;
} else {
bu_vls_printf(ged_result_str, "Invalid format string '%s'", format_string);
ret = GED_ERROR;
}
}
bu_vls_free(&str);
return ret;
}
int
ged_wcodes(struct ged *gedp, int argc, const char *argv[])
{
int i;
int status;
FILE *fp;
struct directory *dp;
static const char *usage = "filename object(s)";
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 ((fp = fopen(argv[1], "w")) == NULL) {
bu_vls_printf(gedp->ged_result_str, "%s: Failed to open file - %s",
argv[0], argv[1]);
return GED_ERROR;
}
path = (struct directory **)bu_calloc(PATH_STEP, sizeof(struct directory *), "alloc initial path");
path_capacity = PATH_STEP;
for (i = 2; i < argc; ++i) {
if ((dp = db_lookup(gedp->ged_wdbp->dbip, argv[i], LOOKUP_NOISY)) != RT_DIR_NULL) {
status = wcodes_printcodes(gedp, fp, dp, 0);
if (status == GED_ERROR) {
(void)fclose(fp);
return GED_ERROR;
}
}
}
(void)fclose(fp);
bu_free(path, "dealloc path");
path = NULL;
path_capacity = 0;
return GED_OK;
}
/**
* Checks for the existence of a specified object.
*/
int
ged_exists(struct ged *gedp, int argc, const char *argv_orig[])
{
/* struct directory *dp;*/
static const char *usage = "object";
struct exists_data ed;
struct bu_vls message = BU_VLS_INIT_ZERO;
int result;
char **argv = bu_dup_argv(argc, argv_orig);
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_orig[0], usage);
return GED_HELP;
}
/*
if (argc != 2) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv_orig[0], usage);
return GED_ERROR;
}
*/
ed.t_wp = &argv[1];
ed.gedp = gedp;
ed.t_wp_op = NULL;
ed.message = &message;
result = oexpr(t_lex(*(ed.t_wp), &ed), &ed);
if (result)
bu_vls_printf(gedp->ged_result_str, "1");
else
bu_vls_printf(gedp->ged_result_str, "0");
if (bu_vls_strlen(ed.message) > 0) {
bu_vls_printf(gedp->ged_result_str, "%s", bu_vls_addr(ed.message));
bu_vls_free(&message);
return GED_ERROR;
}
bu_vls_free(&message);
if (*(ed.t_wp) != NULL && *++(ed.t_wp) != NULL) {
return GED_ERROR;
} else {
return GED_OK;
}
}
int
ged_bot_flip(struct ged *gedp, int argc, const char *argv[])
{
int i;
struct directory *dp;
struct rt_db_internal intern;
struct rt_bot_internal *bot;
static const char *usage = "bot [bot2 bot3 ...]";
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;
}
for (i = 1; i < argc; ++i) {
/* Skip past any path elements */
char *obj = (char *)bu_calloc(strlen(argv[i]), sizeof(char), "ged_bot_flip obj");
bu_basename(obj, argv[i]);
if (BU_STR_EQUAL(obj, ".")) {
/* malformed path, lookup using exactly what was provided */
bu_free(obj, "free bu_basename");
obj = bu_strdup(argv[i]);
}
if ((dp = db_lookup(gedp->ged_wdbp->dbip, obj, LOOKUP_QUIET)) == RT_DIR_NULL) {
bu_vls_printf(gedp->ged_result_str, "%s: db_lookup(%s) error\n", argv[0], obj);
} else {
GED_DB_GET_INTERNAL(gedp, &intern, 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!\n", argv[0], obj);
} else {
bot = (struct rt_bot_internal *)intern.idb_ptr;
rt_bot_flip(bot);
GED_DB_PUT_INTERNAL(gedp, dp, &intern, gedp->ged_wdbp->wdb_resp, GED_ERROR);
}
}
bu_free(obj, "free obj");
}
return GED_OK;
}
int
ged_comb_color(struct rt_wdb *wdbp, int argc, const char *argv[])
{
int i;
int val;
register struct directory *dp;
struct rt_db_internal intern;
struct rt_comb_internal *comb;
static const char *usage = "comb_color combination R G B";
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;
}
if (argc != 5) {
bu_vls_printf(&wdbp->wdb_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
GED_DB_LOOKUP(wdbp, dp, argv[1], LOOKUP_NOISY, GED_ERROR);
GED_CHECK_COMB(wdbp, dp, GED_ERROR);
GED_DB_GET_INTERNAL(wdbp, &intern, dp, (fastf_t *)NULL, &rt_uniresource, GED_ERROR);
comb = (struct rt_comb_internal *)intern.idb_ptr;
RT_CK_COMB(comb);
for (i = 0; i < 3; ++i) {
if (sscanf(argv[i+2], "%d", &val) != 1 || val < 0 || 255 < val) {
bu_vls_printf(&wdbp->wdb_result_str,"RGB value out of range: %s", argv[i + 2]);
rt_db_free_internal(&intern, &rt_uniresource);
return GED_ERROR;
}
else
comb->rgb[i] = val;
}
comb->rgb_valid = 1;
GED_DB_PUT_INTERNAL(wdbp, dp, &intern, &rt_uniresource, GED_ERROR);
return GED_OK;
}
/*
* Listen for framebuffer clients.
*
* Usage:
* procname listen port
*
* Returns the port number actually used.
*
*/
HIDDEN int
fbo_listen_tcl(ClientData clientData, Tcl_Interp *interp, int argc, char **argv)
{
struct fb_obj *fbop = (struct fb_obj *)clientData;
struct bu_vls vls;
bu_vls_init(&vls);
if (fbop->fbo_fbs.fbs_fbp == FBIO_NULL) {
bu_vls_printf(&vls, "%s listen: framebuffer not open!\n", argv[0]);
Tcl_AppendResult(interp, bu_vls_addr(&vls), (char *)NULL);
bu_vls_free(&vls);
return TCL_ERROR;
}
/* return the port number */
if (argc == 2) {
bu_vls_printf(&vls, "%d", fbop->fbo_fbs.fbs_listener.fbsl_port);
Tcl_AppendResult(interp, bu_vls_addr(&vls), (char *)NULL);
bu_vls_free(&vls);
return TCL_OK;
}
if (argc == 3) {
int port;
if (sscanf(argv[2], "%d", &port) != 1) {
Tcl_AppendResult(interp, "listen: bad value - ", argv[2], "\n", (char *)NULL);
return TCL_ERROR;
}
if (port >= 0)
fbs_open(interp, &fbop->fbo_fbs, port);
else {
fbs_close(interp, &fbop->fbo_fbs);
}
bu_vls_printf(&vls, "%d", fbop->fbo_fbs.fbs_listener.fbsl_port);
Tcl_AppendResult(interp, bu_vls_addr(&vls), (char *)NULL);
bu_vls_free(&vls);
return TCL_OK;
}
bu_vls_printf(&vls, "helplib fb_listen");
Tcl_Eval(interp, bu_vls_addr(&vls));
bu_vls_free(&vls);
return TCL_ERROR;
}
int
ged_adjust(struct ged *gedp, int argc, const char *argv[])
{
int status;
struct directory *dp;
char *name;
struct rt_db_internal intern;
static const char *usage = "object attr value ?attr value?";
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 < 4) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
name = (char *)argv[1];
GED_DB_LOOKUP(gedp, dp, name, LOOKUP_QUIET, GED_ERROR);
GED_DB_GET_INTERNAL(gedp, &intern, dp, (matp_t)NULL, &rt_uniresource, GED_ERROR);
RT_CK_DB_INTERNAL(&intern);
/* Find out what type of object we are dealing with and tweak it. */
RT_CK_FUNCTAB(intern.idb_meth);
if (!intern.idb_meth->ft_adjust) {
bu_vls_printf(gedp->ged_result_str, "wdb_export(%s) adjust failure", name);
return GED_ERROR;
}
status = intern.idb_meth->ft_adjust(gedp->ged_result_str, &intern, argc-2, argv+2);
if (status == GED_OK && wdb_put_internal(gedp->ged_wdbp, name, &intern, 1.0) < 0) {
bu_vls_printf(gedp->ged_result_str, "wdb_export(%s) failure", name);
rt_db_free_internal(&intern);
return GED_ERROR;
}
return GED_OK;
}
static void
print_cmd_args(struct bu_vls *output, int argc, const char *argv[])
{
int i;
bu_vls_printf(output, "Command args: '");
for (i = 0; i < argc; i++) {
bu_vls_printf(output, "%s", argv[i]);
if (i < argc - 1) {
bu_vls_printf(output, " ");
} else {
bu_vls_printf(output, "'\n");
}
}
}
