/**
* Returns -
* 0 OK
* !0 failure
*/
int
rt_arbn_prep(struct soltab *stp, struct rt_db_internal *ip, struct rt_i *rtip)
{
struct rt_arbn_internal *aip;
vect_t work;
fastf_t f;
size_t i;
size_t j;
size_t k;
int *used = (int *)0; /* plane eqn use count */
const struct bn_tol *tol = &rtip->rti_tol;
RT_CK_DB_INTERNAL(ip);
aip = (struct rt_arbn_internal *)ip->idb_ptr;
RT_ARBN_CK_MAGIC(aip);
used = (int *)bu_malloc(aip->neqn*sizeof(int), "arbn used[]");
/*
* ARBN must be convex. Test for concavity.
* Byproduct is an enumeration of all the vertices,
* which are used to make the bounding RPP. No need
* to call the bbox routine, as the work must be duplicated
* here to count faces.
*/
/* Zero face use counts
* and make sure normal vectors are unit vectors
*/
for (i = 0; i < aip->neqn; i++) {
double normalLen = MAGNITUDE(aip->eqn[i]);
double scale;
if (ZERO(normalLen)) {
bu_log("arbn has zero length normal vector\n");
return 1;
}
scale = 1.0 / normalLen;
HSCALE(aip->eqn[i], aip->eqn[i], scale);
used[i] = 0;
}
for (i = 0; i < aip->neqn-2; i++) {
for (j=i+1; j<aip->neqn-1; j++) {
double dot;
/* If normals are parallel, no intersection */
dot = VDOT(aip->eqn[i], aip->eqn[j]);
if (BN_VECT_ARE_PARALLEL(dot, tol)) continue;
/* Have an edge line, isect with higher numbered planes */
for (k=j+1; k<aip->neqn; k++) {
size_t m;
size_t next_k;
point_t pt;
next_k = 0;
if (bn_mkpoint_3planes(pt, aip->eqn[i], aip->eqn[j], aip->eqn[k]) < 0) continue;
/* See if point is outside arb */
for (m = 0; m < aip->neqn; m++) {
if (i == m || j == m || k == m)
continue;
if (VDOT(pt, aip->eqn[m])-aip->eqn[m][3] > tol->dist) {
next_k = 1;
break;
}
}
if (next_k != 0) continue;
VMINMAX(stp->st_min, stp->st_max, pt);
/* Increment "face used" counts */
used[i]++;
used[j]++;
used[k]++;
}
}
}
/* If any planes were not used, then arbn is not convex */
for (i = 0; i < aip->neqn; i++) {
if (used[i] != 0) continue; /* face was used */
bu_log("arbn(%s) face %zu unused, solid is not convex\n",
stp->st_name, i);
bu_free((char *)used, "arbn used[]");
return -1; /* BAD */
}
bu_free((char *)used, "arbn used[]");
stp->st_specific = (void *)aip;
ip->idb_ptr = ((void *)0); /* indicate we stole it */
VADD2SCALE(stp->st_center, stp->st_min, stp->st_max, 0.5);
VSUB2SCALE(work, stp->st_max, stp->st_min, 0.5);
f = work[X];
if (work[Y] > f) f = work[Y];
if (work[Z] > f) f = work[Z];
stp->st_aradius = f;
stp->st_bradius = MAGNITUDE(work);
return 0; /* OK */
}
/**
* Given a pointer to an internal GED database object, mirror the
* object's values about the given transformation matrix.
*/
int
rt_epa_mirror(struct rt_db_internal *ip, register const plane_t plane)
{
struct rt_epa_internal *epa;
mat_t mirmat;
mat_t rmat;
mat_t temp;
vect_t nvec;
vect_t xvec;
vect_t mirror_dir;
point_t mirror_pt;
fastf_t ang;
point_t pt;
vect_t h;
vect_t au;
vect_t n;
static point_t origin = {0.0, 0.0, 0.0};
RT_CK_DB_INTERNAL(ip);
epa = (struct rt_epa_internal *)ip->idb_ptr;
RT_EPA_CK_MAGIC(epa);
MAT_IDN(mirmat);
VMOVE(mirror_dir, plane);
VSCALE(mirror_pt, plane, plane[W]);
/* Build mirror transform matrix, for those who need it. */
/* First, perform a mirror down the X axis */
mirmat[0] = -1.0;
/* Create the rotation matrix */
VSET(xvec, 1, 0, 0);
VCROSS(nvec, xvec, mirror_dir);
VUNITIZE(nvec);
ang = -acos(VDOT(xvec, mirror_dir));
bn_mat_arb_rot(rmat, origin, nvec, ang*2.0);
/* Add the rotation to mirmat */
MAT_COPY(temp, mirmat);
bn_mat_mul(mirmat, temp, rmat);
/* Add the translation to mirmat */
mirmat[3 + X*4] += mirror_pt[X] * mirror_dir[X];
mirmat[3 + Y*4] += mirror_pt[Y] * mirror_dir[Y];
mirmat[3 + Z*4] += mirror_pt[Z] * mirror_dir[Z];
VMOVE(pt, epa->epa_V);
MAT4X3PNT(epa->epa_V, mirmat, pt);
VMOVE(h, epa->epa_H);
VMOVE(au, epa->epa_Au);
VUNITIZE(h);
VUNITIZE(au);
VCROSS(n, mirror_dir, epa->epa_H);
VUNITIZE(n);
ang = M_PI_2 - acos(VDOT(h, mirror_dir));
bn_mat_arb_rot(rmat, origin, n, ang*2);
VMOVE(h, epa->epa_H);
MAT4X3VEC(epa->epa_H, rmat, h);
VCROSS(n, mirror_dir, epa->epa_Au);
VUNITIZE(n);
ang = M_PI_2 - acos(VDOT(au, mirror_dir));
bn_mat_arb_rot(rmat, origin, n, ang*2);
VMOVE(au, epa->epa_Au);
MAT4X3VEC(epa->epa_Au, rmat, au);
return 0;
}
int
ged_otranslate(struct ged *gedp, int argc, const char *argv[])
{
struct directory *dp;
struct _ged_trace_data gtd;
struct rt_db_internal intern;
vect_t delta;
double scan[3];
mat_t dmat;
mat_t emat;
mat_t tmpMat;
mat_t invXform;
point_t rpp_min;
point_t rpp_max;
static const char *usage = "obj dx dy dz";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_READ_ONLY(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* must be wanting help */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_HELP;
}
if (argc != 5) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
if (_ged_get_obj_bounds2(gedp, 1, argv+1, >d, rpp_min, rpp_max) == GED_ERROR)
return GED_ERROR;
dp = gtd.gtd_obj[gtd.gtd_objpos-1];
if (!(dp->d_flags & RT_DIR_SOLID)) {
if (_ged_get_obj_bounds(gedp, 1, argv+1, 1, rpp_min, rpp_max) == GED_ERROR)
return GED_ERROR;
}
if (sscanf(argv[2], "%lf", &scan[X]) != 1) {
bu_vls_printf(gedp->ged_result_str, "%s: bad x value - %s", argv[0], argv[2]);
return GED_ERROR;
}
if (sscanf(argv[3], "%lf", &scan[Y]) != 1) {
bu_vls_printf(gedp->ged_result_str, "%s: bad y value - %s", argv[0], argv[3]);
return GED_ERROR;
}
if (sscanf(argv[4], "%lf", &scan[Z]) != 1) {
bu_vls_printf(gedp->ged_result_str, "%s: bad z value - %s", argv[0], argv[4]);
return GED_ERROR;
}
MAT_IDN(dmat);
VSCALE(delta, scan, gedp->ged_wdbp->dbip->dbi_local2base);
MAT_DELTAS_VEC(dmat, delta);
bn_mat_inv(invXform, gtd.gtd_xform);
bn_mat_mul(tmpMat, invXform, dmat);
bn_mat_mul(emat, tmpMat, gtd.gtd_xform);
GED_DB_GET_INTERNAL(gedp, &intern, dp, emat, &rt_uniresource, GED_ERROR);
RT_CK_DB_INTERNAL(&intern);
GED_DB_PUT_INTERNAL(gedp, dp, &intern, &rt_uniresource, GED_ERROR);
return GED_OK;
}
/**
* R T _ G E T T R E E _ L E A F
*
* This routine must be prepared to run in parallel.
*/
HIDDEN union tree *rt_gettree_leaf(struct db_tree_state *tsp, struct db_full_path *pathp, struct rt_db_internal *ip, genptr_t client_data)
/*const*/
/*const*/
{
register struct soltab *stp;
union tree *curtree;
struct directory *dp;
register matp_t mat;
int i;
struct rt_i *rtip;
RT_CK_DBTS(tsp);
RT_CK_DBI(tsp->ts_dbip);
RT_CK_FULL_PATH(pathp);
RT_CK_DB_INTERNAL(ip);
rtip = tsp->ts_rtip;
RT_CK_RTI(rtip);
RT_CK_RESOURCE(tsp->ts_resp);
dp = DB_FULL_PATH_CUR_DIR(pathp);
/* Determine if this matrix is an identity matrix */
if ( !bn_mat_is_equal(tsp->ts_mat, bn_mat_identity, &rtip->rti_tol)) {
/* Not identity matrix */
mat = (matp_t)tsp->ts_mat;
} else {
/* Identity matrix */
mat = (matp_t)0;
}
/*
* Check to see if this exact solid has already been processed.
* Match on leaf name and matrix. Note that there is a race here
* between having st_id filled in a few lines below (which is
* necessary for calling ft_prep), and ft_prep filling in
* st_aradius. Fortunately, st_aradius starts out as zero, and
* will never go down to -1 unless this soltab structure has
* become a dead solid, so by testing against -1 (instead of <= 0,
* like before, oops), it isn't a problem.
*/
stp = rt_find_identical_solid( mat, dp, rtip );
if ( stp->st_id != 0 ) {
/* stp is an instance of a pre-existing solid */
if ( stp->st_aradius <= -1 ) {
/* It's dead, Jim. st_uses was not incremented. */
return( TREE_NULL ); /* BAD: instance of dead solid */
}
goto found_it;
}
if ( rtip->rti_add_to_new_solids_list ) {
bu_ptbl_ins( &rtip->rti_new_solids, (long *)stp );
}
stp->st_id = ip->idb_type;
stp->st_meth = &rt_functab[ip->idb_type];
if ( mat ) {
mat = stp->st_matp;
} else {
mat = (matp_t)bn_mat_identity;
}
RT_CK_DB_INTERNAL( ip );
/* init solid's maxima and minima */
VSETALL( stp->st_max, -INFINITY );
VSETALL( stp->st_min, INFINITY );
/*
* If the ft_prep routine wants to keep the internal structure,
* that is OK, as long as idb_ptr is set to null. Note that the
* prep routine may have changed st_id.
*/
if ( stp->st_meth->ft_prep( stp, ip, rtip ) ) {
int hash;
/* Error, solid no good */
bu_log("rt_gettree_leaf(%s): prep failure\n", dp->d_namep );
/* Too late to delete soltab entry; mark it as "dead" */
hash = db_dirhash( dp->d_namep );
ACQUIRE_SEMAPHORE_TREE(hash);
stp->st_aradius = -1;
stp->st_uses--;
RELEASE_SEMAPHORE_TREE(hash);
return( TREE_NULL ); /* BAD */
}
if ( rtip->rti_dont_instance ) {
/*
* If instanced solid refs are not being compressed, then
* memory isn't an issue, and the application (such as
* solids_on_ray) probably cares about the full path of this
* solid, from root to leaf. So make it available here.
* (stp->st_dp->d_uses could be the way to discriminate
* references uniquely, if the path isn't enough. To locate
* given dp and d_uses, search dp->d_use_hd list. Question
* is, where to stash current val of d_uses?)
*/
db_full_path_init( &stp->st_path );
db_dup_full_path( &stp->st_path, pathp );
} else {
/*
* If there is more than just a direct reference to this leaf
* from it's containing region, copy that below-region path
* into st_path. Otherwise, leave st_path's magic number 0.
*
* XXX nothing depends on this behavior yet, and this whole
* XXX 'else' clause might well be deleted. -Mike
*/
i = pathp->fp_len-1;
if ( i > 0 && !(pathp->fp_names[i-1]->d_flags & DIR_REGION) ) {
/* Search backwards for region. If no region, use whole path */
for ( --i; i > 0; i-- ) {
if ( pathp->fp_names[i-1]->d_flags & DIR_REGION ) break;
}
if ( i < 0 ) i = 0;
db_full_path_init( &stp->st_path );
db_dup_path_tail( &stp->st_path, pathp, i );
}
}
if (RT_G_DEBUG&DEBUG_TREEWALK && stp->st_path.magic == DB_FULL_PATH_MAGIC) {
char *sofar = db_path_to_string(&stp->st_path);
bu_log("rt_gettree_leaf() st_path=%s\n", sofar );
bu_free(sofar, "path string");
}
if (RT_G_DEBUG&DEBUG_SOLIDS) {
struct bu_vls str;
bu_log("\n---Primitive %d: %s\n", stp->st_bit, dp->d_namep);
bu_vls_init( &str );
/* verbose=1, mm2local=1.0 */
if ( stp->st_meth->ft_describe( &str, ip, 1, 1.0, tsp->ts_resp, tsp->ts_dbip ) < 0 ) {
bu_log("rt_gettree_leaf(%s): solid describe failure\n",
dp->d_namep );
}
bu_log( "%s: %s", dp->d_namep, bu_vls_addr( &str ) );
bu_vls_free( &str );
}
found_it:
RT_GET_TREE( curtree, tsp->ts_resp );
curtree->magic = RT_TREE_MAGIC;
curtree->tr_op = OP_SOLID;
curtree->tr_a.tu_stp = stp;
/* regionp will be filled in later by rt_tree_region_assign() */
curtree->tr_a.tu_regionp = (struct region *)0;
if (RT_G_DEBUG&DEBUG_TREEWALK) {
char *sofar = db_path_to_string(pathp);
bu_log("rt_gettree_leaf() %s\n", sofar );
bu_free(sofar, "path string");
}
return(curtree);
}
