int
cm_orientation(const int argc, const char **argv)
{
int i;
quat_t quat;
if (argc < 4)
return -1;
for (i = 0; i < 4; i++)
quat[i] = atof(argv[i+1]);
quat_quat2mat(Viewrotscale, quat);
return 0;
}
int
ged_orient(struct ged *gedp, int argc, const char *argv[])
{
quat_t quat;
static const char *usage = "quat";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_VIEW(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* 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 && argc != 5) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
/* set view orientation */
if (argc == 2) {
if (bn_decode_quat(quat, argv[1]) != 4) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
} else {
int i;
for (i = 1; i < 5; ++i) {
double scan;
if (sscanf(argv[i], "%lf", &scan) != 1) {
bu_vls_printf(gedp->ged_result_str, "ged_orient: bad value - %s\n", argv[i-1]);
return GED_ERROR;
}
/* convert from double to fastf_t */
quat[i-1] = scan;
}
}
quat_quat2mat(gedp->ged_gvp->gv_rotation, quat);
ged_view_update(gedp->ged_gvp);
return GED_OK;
}
int
ged_quat(struct ged *gedp, int argc, const char *argv[])
{
quat_t quat;
double scan[4];
static const char *usage = "a b c d";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_VIEW(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* return Viewrot as a quaternion */
if (argc == 1) {
quat_mat2quat(quat, gedp->ged_gvp->gv_rotation);
bu_vls_printf(gedp->ged_result_str, "%.12g %.12g %.12g %.12g", V4ARGS(quat));
return GED_OK;
}
if (argc != 5) {
bu_vls_printf(gedp->ged_result_str, "Usage: view %s %s", argv[0], usage);
return GED_ERROR;
}
/* Set the view orientation given a quaternion */
if (sscanf(argv[1], "%lf", &scan[0]) != 1
|| sscanf(argv[2], "%lf", &scan[1]) != 1
|| sscanf(argv[3], "%lf", &scan[2]) != 1
|| sscanf(argv[4], "%lf", &scan[3]) != 1)
{
bu_vls_printf(gedp->ged_result_str, "view %s: bad value detected - %s %s %s %s",
argv[0], argv[1], argv[2], argv[3], argv[4]);
return GED_ERROR;
}
HMOVE(quat, scan);
quat_quat2mat(gedp->ged_gvp->gv_rotation, quat);
ged_view_update(gedp->ged_gvp);
return GED_OK;
}
int
bn_math_cmd(ClientData clientData, Tcl_Interp *interp, int argc, char **argv)
{
void (*math_func)();
struct bu_vls result;
math_func = (void (*)())clientData; /* object-to-function cast */
bu_vls_init(&result);
if (math_func == bn_mat_mul) {
mat_t o, a, b;
if (argc < 3 || bn_decode_mat(a, argv[1]) < 16 ||
bn_decode_mat(b, argv[2]) < 16) {
bu_vls_printf(&result, "usage: %s matA matB", argv[0]);
goto error;
}
bn_mat_mul(o, a, b);
bn_encode_mat(&result, o);
} else if (math_func == bn_mat_inv || math_func == bn_mat_trn) {
mat_t o, a;
if (argc < 2 || bn_decode_mat(a, argv[1]) < 16) {
bu_vls_printf(&result, "usage: %s mat", argv[0]);
goto error;
}
(*math_func)(o, a);
bn_encode_mat(&result, o);
} else if (math_func == bn_matXvec) {
mat_t m;
hvect_t i, o;
if (argc < 3 || bn_decode_mat(m, argv[1]) < 16 ||
bn_decode_hvect(i, argv[2]) < 4) {
bu_vls_printf(&result, "usage: %s mat hvect", argv[0]);
goto error;
}
bn_matXvec(o, m, i);
bn_encode_hvect(&result, o);
} else if (math_func == bn_mat4x3pnt) {
mat_t m;
point_t i, o;
if (argc < 3 || bn_decode_mat(m, argv[1]) < 16 ||
bn_decode_vect(i, argv[2]) < 3) {
bu_vls_printf(&result, "usage: %s mat point", argv[0]);
goto error;
}
bn_mat4x3pnt(o, m, i);
bn_encode_vect(&result, o);
} else if (math_func == bn_mat4x3vec) {
mat_t m;
vect_t i, o;
if (argc < 3 || bn_decode_mat(m, argv[1]) < 16 ||
bn_decode_vect(i, argv[2]) < 3) {
bu_vls_printf(&result, "usage: %s mat vect", argv[0]);
goto error;
}
bn_mat4x3vec(o, m, i);
bn_encode_vect(&result, o);
} else if (math_func == bn_hdivide) {
hvect_t i;
vect_t o;
if (argc < 2 || bn_decode_hvect(i, argv[1]) < 4) {
bu_vls_printf(&result, "usage: %s hvect", argv[0]);
goto error;
}
bn_hdivide(o, i);
bn_encode_vect(&result, o);
} else if (math_func == bn_vjoin1) {
point_t o;
point_t b, d;
fastf_t c;
if (argc < 4) {
bu_vls_printf(&result, "usage: %s pnt scale dir", argv[0]);
goto error;
}
if ( bn_decode_vect(b, argv[1]) < 3) goto error;
if (Tcl_GetDouble(interp, argv[2], &c) != TCL_OK) goto error;
if ( bn_decode_vect(d, argv[3]) < 3) goto error;
VJOIN1( o, b, c, d ); /* bn_vjoin1( o, b, c, d ) */
bn_encode_vect(&result, o);
} else if ( math_func == bn_vblend) {
point_t a, c, e;
fastf_t b, d;
if ( argc < 5 ) {
bu_vls_printf(&result, "usage: %s scale pnt scale pnt", argv[0]);
goto error;
}
if ( Tcl_GetDouble(interp, argv[1], &b) != TCL_OK) goto error;
if ( bn_decode_vect( c, argv[2] ) < 3) goto error;
if ( Tcl_GetDouble(interp, argv[3], &d) != TCL_OK) goto error;
if ( bn_decode_vect( e, argv[4] ) < 3) goto error;
VBLEND2( a, b, c, d, e )
bn_encode_vect( &result, a );
} else if (math_func == bn_mat_ae) {
mat_t o;
double az, el;
if (argc < 3) {
bu_vls_printf(&result, "usage: %s azimuth elevation", argv[0]);
goto error;
}
if (Tcl_GetDouble(interp, argv[1], &az) != TCL_OK) goto error;
if (Tcl_GetDouble(interp, argv[2], &el) != TCL_OK) goto error;
bn_mat_ae(o, (fastf_t)az, (fastf_t)el);
bn_encode_mat(&result, o);
} else if (math_func == bn_ae_vec) {
fastf_t az, el;
vect_t v;
if (argc < 2 || bn_decode_vect(v, argv[1]) < 3) {
bu_vls_printf(&result, "usage: %s vect", argv[0]);
goto error;
}
bn_ae_vec(&az, &el, v);
bu_vls_printf(&result, "%g %g", az, el);
} else if (math_func == bn_aet_vec) {
fastf_t az, el, twist, accuracy;
vect_t vec_ae, vec_twist;
if (argc < 4 || bn_decode_vect(vec_ae, argv[1]) < 3 ||
bn_decode_vect(vec_twist, argv[2]) < 3 ||
sscanf(argv[3], "%lf", &accuracy) < 1) {
bu_vls_printf(&result, "usage: %s vec_ae vec_twist accuracy",
argv[0]);
goto error;
}
bn_aet_vec(&az, &el, &twist, vec_ae, vec_twist, accuracy);
bu_vls_printf(&result, "%g %g %g", az, el, twist);
} else if (math_func == bn_mat_angles) {
mat_t o;
double alpha, beta, ggamma;
if (argc < 4) {
bu_vls_printf(&result, "usage: %s alpha beta gamma", argv[0]);
goto error;
}
if (Tcl_GetDouble(interp, argv[1], &alpha) != TCL_OK) goto error;
if (Tcl_GetDouble(interp, argv[2], &beta) != TCL_OK) goto error;
if (Tcl_GetDouble(interp, argv[3], &ggamma) != TCL_OK) goto error;
bn_mat_angles(o, alpha, beta, ggamma);
bn_encode_mat(&result, o);
} else if (math_func == bn_eigen2x2) {
fastf_t val1, val2;
vect_t vec1, vec2;
double a, b, c;
if (argc < 4) {
bu_vls_printf(&result, "usage: %s a b c", argv[0]);
goto error;
}
if (Tcl_GetDouble(interp, argv[1], &a) != TCL_OK) goto error;
if (Tcl_GetDouble(interp, argv[2], &c) != TCL_OK) goto error;
if (Tcl_GetDouble(interp, argv[3], &b) != TCL_OK) goto error;
bn_eigen2x2(&val1, &val2, vec1, vec2, (fastf_t)a, (fastf_t)b,
(fastf_t)c);
bu_vls_printf(&result, "%g %g {%g %g %g} {%g %g %g}", val1, val2,
V3ARGS(vec1), V3ARGS(vec2));
} else if (math_func == bn_mat_fromto) {
mat_t o;
vect_t from, to;
if (argc < 3 || bn_decode_vect(from, argv[1]) < 3 ||
bn_decode_vect(to, argv[2]) < 3) {
bu_vls_printf(&result, "usage: %s vecFrom vecTo", argv[0]);
goto error;
}
bn_mat_fromto(o, from, to);
bn_encode_mat(&result, o);
} else if (math_func == bn_mat_xrot || math_func == bn_mat_yrot ||
math_func == bn_mat_zrot) {
mat_t o;
double s, c;
if (argc < 3) {
bu_vls_printf(&result, "usage: %s sinAngle cosAngle", argv[0]);
goto error;
}
if (Tcl_GetDouble(interp, argv[1], &s) != TCL_OK) goto error;
if (Tcl_GetDouble(interp, argv[2], &c) != TCL_OK) goto error;
(*math_func)(o, s, c);
bn_encode_mat(&result, o);
} else if (math_func == bn_mat_lookat) {
mat_t o;
vect_t dir;
int yflip;
if (argc < 3 || bn_decode_vect(dir, argv[1]) < 3) {
bu_vls_printf(&result, "usage: %s dir yflip", argv[0]);
goto error;
}
if (Tcl_GetBoolean(interp, argv[2], &yflip) != TCL_OK) goto error;
bn_mat_lookat(o, dir, yflip);
bn_encode_mat(&result, o);
} else if (math_func == bn_vec_ortho || math_func == bn_vec_perp) {
vect_t ov, vec;
if (argc < 2 || bn_decode_vect(vec, argv[1]) < 3) {
bu_vls_printf(&result, "usage: %s vec", argv[0]);
goto error;
}
(*math_func)(ov, vec);
bn_encode_vect(&result, ov);
} else if (math_func == bn_mat_scale_about_pt_wrapper) {
mat_t o;
vect_t v;
double scale;
int status;
if (argc < 3 || bn_decode_vect(v, argv[1]) < 3) {
bu_vls_printf(&result, "usage: %s pt scale", argv[0]);
goto error;
}
if (Tcl_GetDouble(interp, argv[2], &scale) != TCL_OK) goto error;
bn_mat_scale_about_pt_wrapper(&status, o, v, scale);
if (status != 0) {
bu_vls_printf(&result, "error performing calculation");
goto error;
}
bn_encode_mat(&result, o);
} else if (math_func == bn_mat_xform_about_pt) {
mat_t o, xform;
vect_t v;
if (argc < 3 || bn_decode_mat(xform, argv[1]) < 16 ||
bn_decode_vect(v, argv[2]) < 3) {
bu_vls_printf(&result, "usage: %s xform pt", argv[0]);
goto error;
}
bn_mat_xform_about_pt(o, xform, v);
bn_encode_mat(&result, o);
} else if (math_func == bn_mat_arb_rot) {
mat_t o;
point_t pt;
vect_t dir;
double angle;
if (argc < 4 || bn_decode_vect(pt, argv[1]) < 3 ||
bn_decode_vect(dir, argv[2]) < 3) {
bu_vls_printf(&result, "usage: %s pt dir angle", argv[0]);
goto error;
}
if (Tcl_GetDouble(interp, argv[3], &angle) != TCL_OK)
return TCL_ERROR;
bn_mat_arb_rot(o, pt, dir, (fastf_t)angle);
bn_encode_mat(&result, o);
} else if (math_func == quat_mat2quat) {
mat_t mat;
quat_t quat;
if (argc < 2 || bn_decode_mat(mat, argv[1]) < 16) {
bu_vls_printf(&result, "usage: %s mat", argv[0]);
goto error;
}
quat_mat2quat(quat, mat);
bn_encode_quat(&result, quat);
} else if (math_func == quat_quat2mat) {
mat_t mat;
quat_t quat;
if (argc < 2 || bn_decode_quat(quat, argv[1]) < 4) {
bu_vls_printf(&result, "usage: %s quat", argv[0]);
goto error;
}
quat_quat2mat(mat, quat);
bn_encode_mat(&result, mat);
} else if (math_func == bn_quat_distance_wrapper) {
quat_t q1, q2;
double d;
if (argc < 3 || bn_decode_quat(q1, argv[1]) < 4 ||
bn_decode_quat(q2, argv[2]) < 4) {
bu_vls_printf(&result, "usage: %s quatA quatB", argv[0]);
goto error;
}
bn_quat_distance_wrapper(&d, q1, q2);
bu_vls_printf(&result, "%g", d);
} else if (math_func == quat_double || math_func == quat_bisect ||
math_func == quat_make_nearest) {
quat_t oqot, q1, q2;
if (argc < 3 || bn_decode_quat(q1, argv[1]) < 4 ||
bn_decode_quat(q2, argv[2]) < 4) {
bu_vls_printf(&result, "usage: %s quatA quatB", argv[0]);
goto error;
}
(*math_func)(oqot, q1, q2);
bn_encode_quat(&result, oqot);
} else if (math_func == quat_slerp) {
quat_t oq, q1, q2;
double d;
if (argc < 4 || bn_decode_quat(q1, argv[1]) < 4 ||
bn_decode_quat(q2, argv[2]) < 4) {
bu_vls_printf(&result, "usage: %s quat1 quat2 factor", argv[0]);
goto error;
}
if (Tcl_GetDouble(interp, argv[3], &d) != TCL_OK) goto error;
quat_slerp(oq, q1, q2, d);
bn_encode_quat(&result, oq);
} else if (math_func == quat_sberp) {
quat_t oq, q1, qa, qb, q2;
double d;
if (argc < 6 || bn_decode_quat(q1, argv[1]) < 4 ||
bn_decode_quat(qa, argv[2]) < 4 || bn_decode_quat(qb, argv[3]) < 4 ||
bn_decode_quat(q2, argv[4]) < 4) {
bu_vls_printf(&result, "usage: %s quat1 quatA quatB quat2 factor",
argv[0]);
goto error;
}
if (Tcl_GetDouble(interp, argv[5], &d) != TCL_OK) goto error;
quat_sberp(oq, q1, qa, qb, q2, d);
bn_encode_quat(&result, oq);
} else if (math_func == quat_exp || math_func == quat_log) {
quat_t qout, qin;
if (argc < 2 || bn_decode_quat(qin, argv[1]) < 4) {
bu_vls_printf(&result, "usage: %s quat", argv[0]);
goto error;
}
(*math_func)(qout, qin);
bn_encode_quat(&result, qout);
} else if (math_func == (void (*)())bn_isect_line3_line3) {
double t, u;
point_t pt, a;
vect_t dir, c;
int i;
static const struct bn_tol tol = {
BN_TOL_MAGIC, 0.005, 0.005*0.005, 1e-6, 1-1e-6
};
if (argc != 5) {
bu_vls_printf(&result,
"Usage: bn_isect_line3_line3 pt dir pt dir (%d args specified)",
argc-1);
goto error;
}
if (bn_decode_vect(pt, argv[1]) < 3) {
bu_vls_printf(&result, "bn_isect_line3_line3 no pt: %s\n", argv[0]);
goto error;
}
if (bn_decode_vect(dir, argv[2]) < 3) {
bu_vls_printf(&result, "bn_isect_line3_line3 no dir: %s\n", argv[0]);
goto error;
}
if (bn_decode_vect(a, argv[3]) < 3) {
bu_vls_printf(&result, "bn_isect_line3_line3 no a pt: %s\n", argv[0]);
goto error;
}
if (bn_decode_vect(c, argv[4]) < 3) {
bu_vls_printf(&result, "bn_isect_line3_line3 no c dir: %s\n", argv[0]);
goto error;
}
i = bn_isect_line3_line3(&t, &u, pt, dir, a, c, &tol);
if (i != 1) {
bu_vls_printf(&result, "bn_isect_line3_line3 no intersection: %s\n", argv[0]);
goto error;
}
VJOIN1(a, pt, t, dir);
bn_encode_vect(&result, a);
} else if (math_func == (void (*)())bn_isect_line2_line2) {
double dist[2];
point_t pt, a;
vect_t dir, c;
int i;
static const struct bn_tol tol = {
BN_TOL_MAGIC, 0.005, 0.005*0.005, 1e-6, 1-1e-6
};
if (argc != 5) {
bu_vls_printf(&result,
"Usage: bn_isect_line2_line2 pt dir pt dir (%d args specified)",
argc-1);
goto error;
}
/* i = bn_isect_line2_line2 {0 0} {1 0} {1 1} {0 -1} */
VSETALL(pt, 0.0);
VSETALL(dir, 0.0);
VSETALL(a, 0.0);
VSETALL(c, 0.0);
if (bn_decode_vect(pt, argv[1]) < 2) {
bu_vls_printf(&result, "bn_isect_line2_line2 no pt: %s\n", argv[0]);
goto error;
}
if (bn_decode_vect(dir, argv[2]) < 2) {
bu_vls_printf(&result, "bn_isect_line2_line2 no dir: %s\n", argv[0]);
goto error;
}
if (bn_decode_vect(a, argv[3]) < 2) {
bu_vls_printf(&result, "bn_isect_line2_line2 no a pt: %s\n", argv[0]);
goto error;
}
if (bn_decode_vect(c, argv[4]) < 2) {
bu_vls_printf(&result, "bn_isect_line2_line2 no c dir: %s\n", argv[0]);
goto error;
}
i = bn_isect_line2_line2(dist, pt, dir, a, c, &tol);
if (i != 1) {
bu_vls_printf(&result, "bn_isect_line2_line2 no intersection: %s\n", argv[0]);
goto error;
}
VJOIN1(a, pt, dist[0], dir);
bu_vls_printf(&result, "%g %g", a[0], a[1]);
} else {
bu_vls_printf(&result, "libbn/bn_tcl.c: math function %s not supported yet\n", argv[0]);
goto error;
}
Tcl_AppendResult(interp, bu_vls_addr(&result), (char *)NULL);
bu_vls_free(&result);
return TCL_OK;
error:
Tcl_AppendResult(interp, bu_vls_addr(&result), (char *)NULL);
bu_vls_free(&result);
return TCL_ERROR;
}
/*
* Returns -
* -2 unknown keyword
* -1 error in processing keyword
* 0 OK
*/
int
multi_words( char *words[], int nwords )
{
if ( strcmp( words[0], "rot" ) == 0 ) {
mat_t mat;
/* Expects rotations rx, ry, rz, in degrees */
if ( nwords < 4 ) return(-1);
MAT_IDN( mat );
bn_mat_angles( mat,
atof( words[1] ),
atof( words[2] ),
atof( words[3] ) );
out_mat( mat, stdout );
return(0);
}
if ( strcmp( words[0], "xlate" ) == 0 ) {
mat_t mat;
if ( nwords < 4 ) return(-1);
/* Expects translations tx, ty, tz */
MAT_IDN( mat );
MAT_DELTAS( mat,
atof( words[1] ),
atof( words[2] ),
atof( words[3] ) );
out_mat( mat, stdout );
return(0);
}
if ( strcmp( words[0], "rot_at" ) == 0 ) {
mat_t mat;
mat_t mat1;
mat_t mat2;
mat_t mat3;
/* JG - Expects x, y, z, rx, ry, rz */
/* Translation back to the origin by (-x, -y, -z) */
/* is done first, then the rotation, and finally */
/* back into the original position by (+x, +y, +z). */
if ( nwords < 7 ) return(-1);
MAT_IDN( mat1 );
MAT_IDN( mat2 );
MAT_IDN( mat3 );
MAT_DELTAS( mat1,
-atof( words[1] ),
-atof( words[2] ),
-atof( words[3] ) );
bn_mat_angles( mat2,
atof( words[4] ),
atof( words[5] ),
atof( words[6] ) );
MAT_DELTAS( mat3,
atof( words[1] ),
atof( words[2] ),
atof( words[3] ) );
bn_mat_mul( mat, mat2, mat1 );
bn_mat_mul2( mat3, mat );
out_mat( mat, stdout );
return(0);
}
if ( strcmp( words[0], "orient" ) == 0 ) {
register int i;
mat_t mat;
double args[8];
/* Expects tx, ty, tz, rx, ry, rz, [scale]. */
/* All rotation is done first, then translation */
/* Note: word[0] and args[0] are the keyword */
if ( nwords < 6+1 ) return(-1);
for ( i=1; i<6+1; i++ )
args[i] = 0;
args[7] = 1.0; /* optional arg, default to 1 */
for ( i=1; i<nwords; i++ )
args[i] = atof( words[i] );
MAT_IDN( mat );
bn_mat_angles( mat, args[4], args[5], args[6] );
MAT_DELTAS( mat, args[1], args[2], args[3] );
if ( NEAR_ZERO( args[7], VDIVIDE_TOL ) ) {
/* Nearly zero, signal error */
fprintf(stderr, "Orient scale arg is near zero ('%s')\n",
words[7] );
return(-1);
} else {
mat[15] = 1 / args[7];
}
out_mat( mat, stdout );
return(0);
}
if ( strcmp( words[0], "ae" ) == 0 ) {
mat_t mat;
fastf_t az, el;
if ( nwords < 3 ) return(-1);
/* Expects azimuth, elev, optional twist */
az = atof(words[1]);
el = atof(words[2]);
#if 0
if ( nwords == 3 )
twist = 0.0;
else
twist = atof(words[3]);
#endif
MAT_IDN( mat );
/* XXX does not take twist, for now XXX */
bn_mat_ae( mat, az, el );
out_mat( mat, stdout );
return(0);
}
if ( strcmp( words[0], "arb_rot_pt" ) == 0 ) {
mat_t mat;
point_t pt1, pt2;
vect_t dir;
fastf_t ang;
if ( nwords < 1+3+3+1 ) return(-1);
/* Expects point1, point2, angle */
VSET( pt1, atof(words[1]), atof(words[2]), atof(words[3]) );
VSET( pt2, atof(words[4]), atof(words[5]), atof(words[6]) );
ang = atof(words[7]) * bn_degtorad;
VSUB2( dir, pt2, pt2 );
VUNITIZE(dir);
MAT_IDN( mat );
bn_mat_arb_rot( mat, pt1, dir, ang );
out_mat( mat, stdout );
return(0);
}
if ( strcmp( words[0], "arb_rot_dir" ) == 0 ) {
mat_t mat;
point_t pt1;
vect_t dir;
fastf_t ang;
if ( nwords < 1+3+3+1 ) return(-1);
/* Expects point1, dir, angle */
VSET( pt1, atof(words[1]), atof(words[2]), atof(words[3]) );
VSET( dir, atof(words[4]), atof(words[5]), atof(words[6]) );
ang = atof(words[7]) * bn_degtorad;
VUNITIZE(dir);
MAT_IDN( mat );
bn_mat_arb_rot( mat, pt1, dir, ang );
out_mat( mat, stdout );
return(0);
}
if ( strcmp( words[0], "quat" ) == 0 ) {
mat_t mat;
quat_t quat;
/* Usage: quat x, y, z, w */
if ( nwords < 5 ) return -1;
QSET( quat, atof(words[1]), atof(words[2]),
atof(words[3]), atof(words[4]) );
quat_quat2mat( mat, quat );
out_mat( mat, stdout);
return 0;
}
if ( strcmp( words[0], "fromto" ) == 0 ) {
mat_t mat;
point_t cur;
point_t next;
vect_t from;
vect_t to;
/* Usage: fromto +Z cur_xyz next_xyz */
if ( nwords < 8 ) return -1;
if ( strcmp( words[1], "+X" ) == 0 ) {
VSET( from, 1, 0, 0 );
} else if ( strcmp( words[1], "-X" ) == 0 ) {
VSET( from, -1, 0, 0 );
} else if ( strcmp( words[1], "+Y" ) == 0 ) {
VSET( from, 0, 1, 0 );
} else if ( strcmp( words[1], "-Y" ) == 0 ) {
VSET( from, 0, -1, 0 );
} else if ( strcmp( words[1], "+Z" ) == 0 ) {
VSET( from, 0, 0, 1 );
} else if ( strcmp( words[1], "-Z" ) == 0 ) {
VSET( from, 0, 0, -1 );
} else {
fprintf(stderr, "fromto '%s' is not +/-XYZ\n", words[1]);
return -1;
}
VSET( cur, atof(words[2]), atof(words[3]), atof(words[4]) );
VSET( next, atof(words[5]), atof(words[6]), atof(words[7]) );
VSUB2( to, next, cur );
VUNITIZE(to);
bn_mat_fromto( mat, from, to );
/* Check to see if it worked. */
{
vect_t got;
MAT4X3VEC( got, mat, from );
if ( VDOT( got, to ) < 0.9 ) {
bu_log("\ntabsub ERROR: At t=%s, bn_mat_fromto failed!\n", chanwords[0] );
VPRINT("\tfrom", from);
VPRINT("\tto", to);
VPRINT("\tgot", got);
}
}
out_mat( mat, stdout );
return 0;
}
return(-2); /* Unknown keyword */
}
int
ged_pov(struct ged *gedp, int argc, const char *argv[])
{
vect_t center;
quat_t quat;
vect_t eye_pos;
/* intentionally double for scan */
double scale;
double perspective;
static const char *usage = "center quat scale eye_pos perspective";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_VIEW(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* 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 != 6) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
/***************** Get the arguments *******************/
if (bn_decode_vect(center, argv[1]) != 3) {
bu_vls_printf(gedp->ged_result_str, "ged_pov: bad center - %s\n", argv[1]);
return TCL_ERROR;
}
if (bn_decode_quat(quat, argv[2]) != 4) {
bu_vls_printf(gedp->ged_result_str, "ged_pov: bad quat - %s\n", argv[2]);
return TCL_ERROR;
}
if (sscanf(argv[3], "%lf", &scale) != 1) {
bu_vls_printf(gedp->ged_result_str, "ged_pov: bad scale - %s\n", argv[3]);
return TCL_ERROR;
}
if (bn_decode_vect(eye_pos, argv[4]) != 3) {
bu_vls_printf(gedp->ged_result_str, "ged_pov: bad eye position - %s\n", argv[4]);
return TCL_ERROR;
}
if (sscanf(argv[5], "%lf", &perspective) != 1) {
bu_vls_printf(gedp->ged_result_str, "ged_pov: bad perspective - %s\n", argv[5]);
return TCL_ERROR;
}
/***************** Use the arguments *******************/
VSCALE(center, center, gedp->ged_wdbp->dbip->dbi_local2base);
MAT_DELTAS_VEC_NEG(gedp->ged_gvp->gv_center, center);
quat_quat2mat(gedp->ged_gvp->gv_rotation, quat);
gedp->ged_gvp->gv_scale = gedp->ged_wdbp->dbip->dbi_local2base * scale;
VSCALE(eye_pos, eye_pos, gedp->ged_wdbp->dbip->dbi_local2base);
VMOVE(gedp->ged_gvp->gv_eye_pos, eye_pos);
gedp->ged_gvp->gv_perspective = perspective;
ged_view_update(gedp->ged_gvp);
return GED_OK;
}
/**
* R E A D _ M A T
*/
void read_mat (struct rt_i *rtip)
{
double scan[16] = MAT_INIT_ZERO;
char *buf;
int status = 0x0;
mat_t m;
mat_t q;
while ((buf = rt_read_cmd(stdin)) != (char *) 0) {
if (bu_strncmp(buf, "eye_pt", 6) == 0) {
if (sscanf(buf + 6, "%lf%lf%lf", &scan[X], &scan[Y], &scan[Z]) != 3) {
bu_exit(1, "nirt: read_mat(): Failed to read eye_pt\n");
}
target(X) = scan[X];
target(Y) = scan[Y];
target(Z) = scan[Z];
status |= RMAT_SAW_EYE;
} else if (bu_strncmp(buf, "orientation", 11) == 0) {
if (sscanf(buf + 11,
"%lf%lf%lf%lf",
&scan[X], &scan[Y], &scan[Z], &scan[W]) != 4) {
bu_exit(1, "nirt: read_mat(): Failed to read orientation\n");
}
MAT_COPY(q, scan);
quat_quat2mat(m, q);
if (nirt_debug & DEBUG_MAT)
bn_mat_print("view matrix", m);
azimuth() = atan2(-m[0], m[1]) / DEG2RAD;
elevation() = atan2(m[10], m[6]) / DEG2RAD;
status |= RMAT_SAW_ORI;
} else if (bu_strncmp(buf, "viewrot", 7) == 0) {
if (sscanf(buf + 7,
"%lf%lf%lf%lf%lf%lf%lf%lf%lf%lf%lf%lf%lf%lf%lf%lf",
&scan[0], &scan[1], &scan[2], &scan[3],
&scan[4], &scan[5], &scan[6], &scan[7],
&scan[8], &scan[9], &scan[10], &scan[11],
&scan[12], &scan[13], &scan[14], &scan[15]) != 16) {
bu_exit(1, "nirt: read_mat(): Failed to read viewrot\n");
}
MAT_COPY(m, scan);
if (nirt_debug & DEBUG_MAT)
bn_mat_print("view matrix", m);
azimuth() = atan2(-m[0], m[1]) / DEG2RAD;
elevation() = atan2(m[10], m[6]) / DEG2RAD;
status |= RMAT_SAW_VR;
}
}
if ((status & RMAT_SAW_EYE) == 0) {
bu_exit(1, "nirt: read_mat(): Was given no eye_pt\n");
}
if ((status & (RMAT_SAW_ORI | RMAT_SAW_VR)) == 0) {
bu_exit(1, "nirt: read_mat(): Was given no orientation or viewrot\n");
}
direct(X) = -m[8];
direct(Y) = -m[9];
direct(Z) = -m[10];
dir2ae();
targ2grid();
shoot("", 0, rtip);
}
