/**
* Function to get the corresponding region entry to a region name.
*/
HIDDEN struct voxelRegion *
getRegionByName(struct voxelRegion *head, const char *regionName) {
struct voxelRegion *ret = NULL;
BU_ASSERT(regionName != NULL);
if (head->regionName == NULL) { /* the first region on this voxel */
head->regionName = bu_strdup(regionName);
ret = head;
}
else {
while (head->nextRegion != NULL) {
if (bu_strcmp(head->regionName, regionName) == 0) {
ret = head;
break;
}
head = head->nextRegion;
}
if (ret == NULL) { /* not found until here */
if (bu_strcmp(head->regionName ,regionName) == 0) /* is it the last one on the list? */
ret = head;
else {
BU_ALLOC(ret, struct voxelRegion);
head->nextRegion = ret;
ret->regionName = bu_strdup(regionName);
}
}
}
return ret;
}
int
rt_gen_elliptical_grid(struct xrays *rays, const struct xray *center_ray, const fastf_t *avec, const fastf_t *bvec, fastf_t gridsize)
{
register struct xrays *xrayp;
int count = 0;
point_t C;
vect_t dir;
vect_t a_dir;
vect_t b_dir;
fastf_t a = MAGNITUDE(avec);
fastf_t b = MAGNITUDE(bvec);
fastf_t x, y;
int acpr = a / gridsize;
int bcpr = b / gridsize;
VMOVE(a_dir, avec);
VUNITIZE(a_dir);
VMOVE(b_dir, bvec);
VUNITIZE(b_dir);
VMOVE(C, center_ray->r_pt);
VMOVE(dir, center_ray->r_dir);
/* make sure avec perpendicular to bvec perpendicular to ray direction */
BU_ASSERT(NEAR_ZERO(VDOT(avec, bvec), VUNITIZE_TOL));
BU_ASSERT(NEAR_ZERO(VDOT(avec, dir), VUNITIZE_TOL));
for (y=gridsize * (-bcpr); y <= b; y=y+gridsize) {
for (x= gridsize * (-acpr); x <= a; x=x+gridsize) {
if (((x*x)/(a*a) + (y*y)/(b*b)) < 1) {
BU_ALLOC(xrayp, struct xrays);
VJOIN2(xrayp->ray.r_pt, C, x, a_dir, y, b_dir);
VMOVE(xrayp->ray.r_dir, dir);
xrayp->ray.index = count++;
xrayp->ray.magic = RT_RAY_MAGIC;
BU_LIST_APPEND(&rays->l, &xrayp->l);
}
}
}
return count;
}
/**
* This one assumes that making all the parameters null is fine.
*/
void
rt_generic_make(const struct rt_functab *ftp, struct rt_db_internal *intern)
{
intern->idb_type = ftp - OBJ;
intern->idb_major_type = DB5_MAJORTYPE_BRLCAD;
BU_ASSERT(&OBJ[intern->idb_type] == ftp);
intern->idb_meth = ftp;
intern->idb_ptr = bu_calloc(1, (unsigned int)ftp->ft_internal_size, "rt_generic_make");
*((uint32_t *)(intern->idb_ptr)) = ftp->ft_internal_magic;
}
int
mk_brep(struct rt_wdb* file, const char* name, ON_Brep* brep)
{
struct rt_brep_internal* bi;
BU_ASSERT(brep != NULL);
BU_ALLOC(bi, struct rt_brep_internal);
bi->magic = RT_BREP_INTERNAL_MAGIC;
bi->brep = new ON_Brep(*brep); /* copy the users' brep */
if (!bi->brep) {
bu_log("mk_brep: Unable to copy BREP\n");
}
return wdb_export(file, name, (genptr_t)bi, ID_BREP, mk_conv2mm);
}
/**
* Routine to make a new REVOLVE solid. The only purpose of this routine
* is to initialize the internal to legal values (e.g., vls)
*/
void
rt_revolve_make(const struct rt_functab *ftp, struct rt_db_internal *intern)
{
struct rt_revolve_internal *rev;
intern->idb_major_type = DB5_MAJORTYPE_BRLCAD;
intern->idb_type = ID_REVOLVE;
BU_ASSERT(&OBJ[intern->idb_type] == ftp);
intern->idb_meth = ftp;
BU_ALLOC(rev, struct rt_revolve_internal);
intern->idb_ptr = (void *)rev;
rev->magic = RT_REVOLVE_INTERNAL_MAGIC;
BU_VLS_INIT(&rev->sketch_name);
rev->skt = NULL;
}
void
rt_binunif_make(const struct rt_functab *ftp, struct rt_db_internal *intern, double diameter)
{
struct rt_binunif_internal *bip;
intern->idb_type = DB5_MINORTYPE_BINU_8BITINT;
intern->idb_major_type = DB5_MAJORTYPE_BINARY_UNIF;
BU_ASSERT(&rt_functab[ID_BINUNIF] == ftp);
intern->idb_meth = ftp;
bip = (struct rt_binunif_internal *)bu_calloc( sizeof( struct rt_binunif_internal), 1,
"rt_binunif_make");
intern->idb_ptr = (genptr_t) bip;
bip->magic = RT_BINUNIF_INTERNAL_MAGIC;
bip->type = DB5_MINORTYPE_BINU_8BITINT;
bip->count = 0;
bip->u.int8 = NULL;
}
int
ged_killtree(struct ged *gedp, int argc, const char *argv[])
{
struct directory *dp;
int i;
int c;
struct killtree_data gktd;
static const char *usage = "[-a|-f|-n] object(s)";
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;
}
gktd.gedp = gedp;
gktd.killrefs = 0;
gktd.print = 0;
gktd.force = 0;
gktd.ac = 1;
gktd.top = NULL;
gktd.av = (char **)bu_calloc(1, sizeof(char *) * AV_STEP, "alloc av");
gktd.av_capacity = AV_STEP;
BU_ASSERT(gktd.ac + argc + 2 < AV_STEP); /* potential -n opts */
gktd.av[0] = "killrefs";
gktd.av[1] = (char *)0;
bu_optind = 1;
while ((c = bu_getopt(argc, (char * const *)argv, "afn")) != -1) {
switch (c) {
case 'a':
gktd.killrefs = 1;
break;
case 'n':
gktd.print = 1;
gktd.av[gktd.ac++] = bu_strdup("-n");
gktd.av[gktd.ac] = (char *)0;
break;
case 'f':
gktd.force = 1;
break;
default:
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
bu_free(gktd.av, "free av (error)");
gktd.av = NULL;
return GED_ERROR;
}
}
argc -= (bu_optind - 1);
argv += (bu_optind - 1);
/* Objects that would be killed are in the first sublist */
if (gktd.print)
bu_vls_printf(gedp->ged_result_str, "{");
for (i = 1; i < argc; i++) {
if ((dp = db_lookup(gedp->ged_wdbp->dbip, argv[i], LOOKUP_NOISY)) == RT_DIR_NULL)
continue;
/* ignore phony objects */
if (dp->d_addr == RT_DIR_PHONY_ADDR)
continue;
/* stash the what's killed so we can find refs elsewhere */
gktd.top = argv[i];
db_functree(gedp->ged_wdbp->dbip, dp,
killtree_callback, killtree_callback,
gedp->ged_wdbp->wdb_resp, (void *)&gktd);
}
/* Close the sublist of would-be killed objects. Also open the
* sublist of objects that reference the would-be killed objects.
*/
if (gktd.print)
bu_vls_printf(gedp->ged_result_str, "} {");
if (gktd.killrefs && gktd.ac > 1) {
gedp->ged_internal_call = 1;
(void)ged_killrefs(gedp, gktd.ac, (const char **)gktd.av);
gedp->ged_internal_call = 0;
for (i = 1; i < gktd.ac; i++) {
if (!gktd.print)
bu_vls_printf(gedp->ged_result_str, "Freeing %s\n", gktd.av[i]);
bu_free((void *)gktd.av[i], "killtree_data");
gktd.av[i] = NULL;
}
}
if (gktd.print)
bu_vls_printf(gedp->ged_result_str, "}");
bu_free(gktd.av, "free av");
gktd.av = NULL;
return GED_OK;
}
/**
* find a new unique name given a list of previously used names, and
* the type of naming mode that described what type of affix to use.
*/
static char *
get_new_name(const char *name,
struct db_i *dbip,
Tcl_HashTable *name_tbl,
Tcl_HashTable *used_names_tbl,
struct ged_concat_data *cc_data)
{
struct bu_vls new_name = BU_VLS_INIT_ZERO;
Tcl_HashEntry *ptr = NULL;
char *aname = NULL;
char *ret_name = NULL;
int int_new=0;
long num=0;
RT_CK_DBI(dbip);
BU_ASSERT(name_tbl);
BU_ASSERT(used_names_tbl);
BU_ASSERT(cc_data);
if (!name) {
bu_log("WARNING: encountered NULL name, renaming to \"UNKNOWN\"\n");
name = "UNKNOWN";
}
ptr = Tcl_CreateHashEntry(name_tbl, name, &int_new);
if (!int_new) {
return (char *)Tcl_GetHashValue(ptr);
}
do {
/* iterate until we find an object name that is not in
* use, trying to accommodate the user's requested affix
* naming mode.
*/
bu_vls_trunc(&new_name, 0);
if (cc_data->copy_mode & NO_AFFIX) {
if (num > 0 && cc_data->copy_mode & CUSTOM_PREFIX) {
/* auto-increment prefix */
bu_vls_printf(&new_name, "%ld_", num);
}
bu_vls_strcat(&new_name, name);
if (num > 0 && cc_data->copy_mode & CUSTOM_SUFFIX) {
/* auto-increment suffix */
bu_vls_printf(&new_name, "_%ld", num);
}
} else if (cc_data->copy_mode & CUSTOM_SUFFIX) {
/* use custom suffix */
bu_vls_strcpy(&new_name, name);
if (num > 0) {
bu_vls_printf(&new_name, "_%ld_", num);
}
bu_vls_vlscat(&new_name, &cc_data->affix);
} else if (cc_data->copy_mode & CUSTOM_PREFIX) {
/* use custom prefix */
bu_vls_vlscat(&new_name, &cc_data->affix);
if (num > 0) {
bu_vls_printf(&new_name, "_%ld_", num);
}
bu_vls_strcat(&new_name, name);
} else if (cc_data->copy_mode & AUTO_SUFFIX) {
/* use auto-incrementing suffix */
bu_vls_strcat(&new_name, name);
bu_vls_printf(&new_name, "_%ld", num);
} else if (cc_data->copy_mode & AUTO_PREFIX) {
/* use auto-incrementing prefix */
bu_vls_printf(&new_name, "%ld_", num);
bu_vls_strcat(&new_name, name);
} else {
/* no custom suffix/prefix specified, use prefix */
if (num > 0) {
bu_vls_printf(&new_name, "_%ld", num);
}
bu_vls_strcpy(&new_name, name);
}
/* make sure it fits for v4 */
if (db_version(cc_data->old_dbip) < 5) {
if (bu_vls_strlen(&new_name) > _GED_V4_MAXNAME) {
bu_log("ERROR: generated new name [%s] is too long (%zu > %d)\n", bu_vls_addr(&new_name), bu_vls_strlen(&new_name), _GED_V4_MAXNAME);
}
return NULL;
}
aname = bu_vls_addr(&new_name);
num++;
} while (db_lookup(dbip, aname, LOOKUP_QUIET) != RT_DIR_NULL ||
Tcl_FindHashEntry(used_names_tbl, aname) != NULL);
/* if they didn't get what they asked for, warn them */
if (num > 1) {
if (cc_data->copy_mode & NO_AFFIX) {
bu_log("WARNING: unable to import [%s] without an affix, imported as [%s]\n", name, bu_vls_addr(&new_name));
} else if (cc_data->copy_mode & CUSTOM_SUFFIX) {
bu_log("WARNING: unable to import [%s] as [%s%s], imported as [%s]\n", name, name, bu_vls_addr(&cc_data->affix), bu_vls_addr(&new_name));
} else if (cc_data->copy_mode & CUSTOM_PREFIX) {
bu_log("WARNING: unable to import [%s] as [%s%s], imported as [%s]\n", name, bu_vls_addr(&cc_data->affix), name, bu_vls_addr(&new_name));
}
}
/* we should now have a unique name. store it in the hash */
ret_name = bu_vls_strgrab(&new_name);
Tcl_SetHashValue(ptr, (ClientData)ret_name);
(void)Tcl_CreateHashEntry(used_names_tbl, ret_name, &int_new);
bu_vls_free(&new_name);
return ret_name;
}
char *
bu_getcwd(char *buf, size_t size)
{
char *cwd = NULL;
char *pwd = NULL;
char cbuf[MAXPATHLEN] = {0};
size_t sz = size;
/* NULL buf means allocate */
if (!buf) {
sz = MAXPATHLEN;
buf = (char *)bu_calloc(1, sz, "alloc bu_getcwd");
}
/* FIRST: try getcwd */
#ifdef HAVE_GETCWD
cwd = getcwd(cbuf, MAXPATHLEN);
if (cwd
&& strlen(cwd) > 0
&& bu_file_exists(cwd, NULL))
{
#if defined(HAVE_WORKING_REALPATH_FUNCTION)
/* FIXME: shouldn't have gotten here with -std=c99 (HAVE_REALPATH test not working right?) */
char rbuf[MAXPATHLEN] = {0};
char *rwd = bu_realpath(cbuf, rbuf);
if (rwd
&& strlen(rwd) > 0
&& bu_file_exists(rwd, NULL))
{
BU_ASSERT(sz > strlen(rwd)+1);
bu_strlcpy(buf, rwd, strlen(rwd)+1);
return buf;
}
#endif /* HAVE_WORKING_REALPATH_FUNCTION */
BU_ASSERT(sz > strlen(cwd)+1);
bu_strlcpy(buf, cwd, strlen(cwd)+1);
return buf;
}
#else
/* quellage */
cwd = memset(cbuf, 0, MAXPATHLEN);
#endif /* HAVE_GETCWD */
/* SECOND: try environment */
pwd = getenv("PWD");
if (pwd
&& strlen(pwd) > 0
&& bu_file_exists(pwd, NULL))
{
#if defined(HAVE_WORKING_REALPATH_FUNCTION)
char rbuf[MAXPATHLEN] = {0};
char *rwd = realpath(pwd, rbuf);
if (rwd
&& strlen(rwd) > 0
&& bu_file_exists(rwd, NULL))
{
BU_ASSERT(sz > strlen(rwd)+1);
bu_strlcpy(buf, rwd, strlen(rwd)+1);
return buf;
}
#endif /* HAVE_WORKING_REALPATH_FUNCTION */
BU_ASSERT(sz > strlen(pwd)+1);
bu_strlcpy(buf, pwd, strlen(pwd)+1);
return buf;
}
/* LAST: punt (but do not return NULL) */
BU_ASSERT(sz > strlen(".")+1);
bu_strlcpy(buf, ".", strlen(".")+1);
return buf;
}
