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