/**
* R T _ E B M _ B R E P
*/
extern "C" void
rt_ebm_brep(ON_Brep **b, const struct rt_db_internal *ip, const struct bn_tol *tol)
{
struct rt_db_internal *tmp_internal;
struct rt_tess_tol ttmptol;
BU_ALLOC(tmp_internal, struct rt_db_internal);
RT_DB_INTERNAL_INIT(tmp_internal);
ttmptol.abs = 0;
ttmptol.rel = 0.01;
ttmptol.norm = 0;
const struct rt_tess_tol *ttol = &ttmptol;
struct model *ebmm = nmg_mm();
struct nmgregion *ebmr;
tmp_internal->idb_ptr = (genptr_t)ip->idb_ptr;
rt_ebm_tess(&ebmr, ebmm, tmp_internal, ttol, tol);
tmp_internal->idb_ptr = (genptr_t)ebmm;
rt_nmg_brep(b, tmp_internal, tol);
FREE_MODEL(ebmm);
bu_free(tmp_internal, "free temporary rt_db_internal");
}
extern "C" void
rt_bot_brep(ON_Brep **b, const struct rt_db_internal *ip, const struct bn_tol *tol)
{
struct rt_db_internal *tmp_internal;
struct rt_tess_tol ttmptol;
BU_ALLOC(tmp_internal, struct rt_db_internal);
RT_DB_INTERNAL_INIT(tmp_internal);
ttmptol.abs = 0;
ttmptol.rel = 0.01;
ttmptol.norm = 0;
const struct rt_tess_tol *ttol = &ttmptol;
struct model *botm = nmg_mm();
struct nmgregion *botr;
tmp_internal->idb_ptr = (void *)ip->idb_ptr;
(void)rt_bot_tess(&botr, botm, tmp_internal, ttol, tol);
tmp_internal->idb_ptr = (void *)botm;
rt_nmg_brep(b, tmp_internal, tol);
FREE_MODEL(botm);
bu_free(tmp_internal, "free temporary rt_db_internal");
}
int
rt_db_get_internal(
struct rt_db_internal *ip,
const struct directory *dp,
const struct db_i *dbip,
const mat_t mat,
struct resource *resp)
{
struct bu_external ext;
int id;
int ret;
RT_DB_INTERNAL_INIT(ip);
if (dbip->dbi_version > 4)
return rt_db_get_internal5(ip, dp, dbip, mat, resp);
BU_EXTERNAL_INIT(&ext);
if (db_get_external(&ext, dp, dbip) < 0)
return -2; /* FAIL */
if (dp->d_flags & RT_DIR_COMB) {
id = ID_COMBINATION;
} else {
/* As a convenience to older ft_import4 routines */
if (mat == NULL) mat = bn_mat_identity;
id = rt_id_solid(&ext);
}
/* ip is already initialized and should not be re-initialized */
ret = -1;
if (OBJ[id].ft_import4) {
ret = OBJ[id].ft_import4(ip, &ext, mat, dbip, resp);
}
if (ret < 0) {
bu_log("rt_db_get_internal(%s): import failure\n",
dp->d_namep);
rt_db_free_internal(ip);
bu_free_external(&ext);
return -1; /* FAIL */
}
bu_free_external(&ext);
RT_CK_DB_INTERNAL(ip);
ip->idb_meth = &OBJ[id];
/* prior to version 5, there are no attributes ... */
bu_avs_init_empty(&ip->idb_avs);
/* ... but this isn't the whole story: */
if (id == ID_COMBINATION) {
const struct rt_comb_internal *comb = (const struct rt_comb_internal *)ip->idb_ptr;
RT_CK_COMB(comb);
db5_sync_comb_to_attr(&ip->idb_avs, comb);
}
return id; /* OK */
}
void
rt_db_free_internal(struct rt_db_internal *ip)
{
RT_CK_DB_INTERNAL(ip);
/* meth is not required since may be asked to free something that
* was never set.
*/
if (ip->idb_meth) {
RT_CK_FUNCTAB(ip->idb_meth);
if (ip->idb_ptr && ip->idb_meth->ft_ifree) {
ip->idb_meth->ft_ifree(ip);
}
}
if (ip->idb_ptr) {
ip->idb_ptr = NULL; /* sanity. Should be handled by INIT, below */
}
if (ip->idb_avs.magic == BU_AVS_MAGIC) {
bu_avs_free(&ip->idb_avs);
}
RT_DB_INTERNAL_INIT(ip);
}
static int
make_tree(struct ged *gedp, struct rt_comb_internal *comb, struct directory *dp, size_t node_count, const char *old_name, const char *new_name, struct rt_tree_array *rt_tree_array, int tree_index)
{
struct rt_db_internal intern;
union tree *final_tree;
if (tree_index)
final_tree = (union tree *)db_mkgift_tree(rt_tree_array, node_count, &rt_uniresource);
else
final_tree = (union tree *)NULL;
RT_DB_INTERNAL_INIT(&intern);
intern.idb_major_type = DB5_MAJORTYPE_BRLCAD;
intern.idb_type = ID_COMBINATION;
intern.idb_meth = &rt_functab[ID_COMBINATION];
intern.idb_ptr = (genptr_t)comb;
comb->tree = final_tree;
if (!BU_STR_EQUAL(new_name, old_name)) {
int flags;
if (comb->region_flag)
flags = RT_DIR_COMB | RT_DIR_REGION;
else
flags = RT_DIR_COMB;
if (dp != RT_DIR_NULL) {
if (db_delete(gedp->ged_wdbp->dbip, dp) || db_dirdelete(gedp->ged_wdbp->dbip, dp)) {
bu_vls_printf(gedp->ged_result_str, "make_tree: Unable to delete directory entry for %s\n", old_name);
intern.idb_meth->ft_ifree(&intern);
return GED_ERROR;
}
}
if ((dp=db_diradd(gedp->ged_wdbp->dbip, new_name, RT_DIR_PHONY_ADDR, 0, flags, (genptr_t)&intern.idb_type)) == RT_DIR_NULL) {
bu_vls_printf(gedp->ged_result_str, "make_tree: Cannot add %s to directory, no changes made\n", new_name);
intern.idb_meth->ft_ifree(&intern);
return 1;
}
} else if (dp == RT_DIR_NULL) {
int flags;
if (comb->region_flag)
flags = RT_DIR_COMB | RT_DIR_REGION;
else
flags = RT_DIR_COMB;
if ((dp=db_diradd(gedp->ged_wdbp->dbip, new_name, RT_DIR_PHONY_ADDR, 0, flags, (genptr_t)&intern.idb_type)) == RT_DIR_NULL) {
bu_vls_printf(gedp->ged_result_str, "make_tree: Cannot add %s to directory, no changes made\n", new_name);
intern.idb_meth->ft_ifree(&intern);
return GED_ERROR;
}
} else {
if (comb->region_flag)
dp->d_flags |= RT_DIR_REGION;
else
dp->d_flags &= ~RT_DIR_REGION;
}
if (rt_db_put_internal(dp, gedp->ged_wdbp->dbip, &intern, &rt_uniresource) < 0) {
bu_vls_printf(gedp->ged_result_str, "make_tree: Unable to write new combination into database.\n");
return GED_ERROR;
}
return GED_OK;
}
/**
* Apply a transformation matrix to the specified 'ip' input revolve
* object, storing the results in the specified 'op' out pointer or
* creating a copy if NULL.
*/
int
rt_revolve_xform(
struct rt_db_internal *op,
const mat_t mat,
struct rt_db_internal *ip,
int release,
struct db_i *dbip,
struct resource *resp)
{
struct rt_revolve_internal *rip, *rop;
point_t tmp_vec;
if (dbip) RT_CK_DBI(dbip);
RT_CK_DB_INTERNAL(ip);
RT_CK_RESOURCE(resp);
rip = (struct rt_revolve_internal *)ip->idb_ptr;
RT_REVOLVE_CK_MAGIC(rip);
if (bu_debug&BU_DEBUG_MEM_CHECK) {
bu_log("Barrier check at start of revolve_xform():\n");
bu_mem_barriercheck();
}
if (op != ip) {
RT_DB_INTERNAL_INIT(op);
BU_ALLOC(rop, struct rt_revolve_internal);
rop->magic = RT_REVOLVE_INTERNAL_MAGIC;
bu_vls_init(&rop->sketch_name);
bu_vls_vlscat(&rop->sketch_name, &rip->sketch_name);
op->idb_ptr = (void *)rop;
op->idb_meth = &OBJ[ID_REVOLVE];
op->idb_major_type = DB5_MAJORTYPE_BRLCAD;
op->idb_type = ID_REVOLVE;
if (ip->idb_avs.magic == BU_AVS_MAGIC) {
bu_avs_init(&op->idb_avs, ip->idb_avs.count, "avs");
bu_avs_merge(&op->idb_avs, &ip->idb_avs);
}
} else {
rop = (struct rt_revolve_internal *)ip->idb_ptr;
}
MAT4X3PNT(tmp_vec, mat, rip->v3d);
VMOVE(rop->v3d, tmp_vec);
MAT4X3VEC(tmp_vec, mat, rip->axis3d);
VMOVE(rop->axis3d, tmp_vec);
V2MOVE(rop->v2d, rip->v2d);
V2MOVE(rop->axis2d, rip->axis2d);
if (release && ip != op) {
rop->skt = rip->skt;
rip->skt = (struct rt_sketch_internal *)NULL;
rt_db_free_internal(ip);
} else if (rip->skt) {
rop->skt = rt_copy_sketch(rip->skt);
} else {
rop->skt = (struct rt_sketch_internal *)NULL;
}
if (bu_debug&BU_DEBUG_MEM_CHECK) {
bu_log("Barrier check at end of revolve_xform():\n");
bu_mem_barriercheck();
}
return 0;
}
/*
* 'make_pnts' command for importing point-cloud data into a 'pnts'
* primitive.
*
* Input values:
* argv[1] object name
* argv[2] filename with path
* argv[3] point data file format string
* argv[4] point data file units string or conversion factor to millimeters
* argv[5] default size of each point
*
*/
int
ged_make_pnts(struct ged *gedp, int argc, const char *argv[])
{
struct directory *dp;
struct rt_db_internal internal;
rt_pnt_type type;
double local2base;
unsigned long numPoints = 0;
struct rt_pnts_internal *pnts;
double defaultSize = 0.0;
void *headPoint = NULL;
FILE *fp;
int temp_string_index = 0; /* index into temp_string, set to first character in temp_string, i.e. the start */
unsigned long int num_doubles_read = 0; /* counters of double read from file */
int current_character_double = 0; /* flag indicating if current character read is part of a double or delimiter */
int previous_character_double = 0; /* flag indicating if previously read character was part of a double or delimiter */
unsigned long int num_characters_read_from_file = 0; /* counter of number of characters read from file */
unsigned long int start_offset_of_current_double = 0; /* character offset from start of file for current double */
int found_double = 0; /* flag indicating if double encountered in file and needs to be processed */
int found_eof = 0; /* flag indicating if end-of-file encountered when reading file */
int done_processing_format_string = 0; /* flag indicating if loop processing format string should be exited */
char *temp_char_ptr = (char *)NULL;
int buf = 0; /* raw character read from file */
double temp_double = 0.0;
char temp_string[1024];
int temp_string_size = 1024; /* number of characters that can be stored in temp_string including null terminator character */
/* it is expected that the character representation of a double will never exceed this size string */
char *endp = (char *)NULL;
struct bu_vls format_string = BU_VLS_INIT_ZERO;
size_t format_string_index = 0;
unsigned int num_doubles_per_point = 0;
void *point = NULL;
char **prompt;
static const char *usage = "point_cloud_name filename_with_path file_format file_data_units default_point_size";
prompt = &p_make_pnts[0];
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);
if (argc > 6) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
/* prompt for point-cloud name */
if (argc < 2) {
bu_vls_printf(gedp->ged_result_str, "%s", prompt[0]);
return GED_MORE;
}
GED_CHECK_EXISTS(gedp, argv[1], LOOKUP_QUIET, GED_ERROR);
/* prompt for data file name with path */
if (argc < 3) {
bu_vls_printf(gedp->ged_result_str, "%s", prompt[1]);
return GED_MORE;
}
/* prompt for data file format */
if (argc < 4) {
bu_vls_printf(gedp->ged_result_str, "%s", prompt[2]);
return GED_MORE;
}
/* Validate 'point file data format string' and return point-cloud type. */
if (str2type(argv[3], &type, gedp->ged_result_str) == GED_ERROR) {
return GED_ERROR;
}
/* prompt for data file units */
if (argc < 5) {
bu_vls_printf(gedp->ged_result_str, "%s", prompt[3]);
return GED_MORE;
}
/* Validate the unit string and return conversion factor to millimeters. */
if (str2mm(argv[4], &local2base, gedp->ged_result_str) == GED_ERROR) {
return GED_ERROR;
}
/* prompt for default point size */
if (argc < 6) {
bu_vls_printf(gedp->ged_result_str, "%s", prompt[4]);
return GED_MORE;
}
defaultSize = strtod(argv[5], &endp);
if ((endp != argv[5]) && (*endp == '\0')) {
/* convert to double success */
if (defaultSize < 0.0) {
bu_vls_printf(gedp->ged_result_str, "Default point size '%lf' must be non-negative.\n", defaultSize);
return GED_ERROR;
}
} else {
bu_vls_printf(gedp->ged_result_str, "Invalid default point size '%s'\n", argv[5]);
return GED_ERROR;
}
bu_vls_strcat(&format_string, argv[3]);
bu_vls_trimspace(&format_string);
/* init database structure */
RT_DB_INTERNAL_INIT(&internal);
internal.idb_major_type = DB5_MAJORTYPE_BRLCAD;
internal.idb_type = ID_PNTS;
internal.idb_meth = &OBJ[ID_PNTS];
BU_ALLOC(internal.idb_ptr, struct rt_pnts_internal);
/* init internal structure */
pnts = (struct rt_pnts_internal *) internal.idb_ptr;
pnts->magic = RT_PNTS_INTERNAL_MAGIC;
pnts->scale = defaultSize;
pnts->type = type;
pnts->count = numPoints; /* set again later */
pnts->point = NULL;
/* empty list head */
switch (type) {
case RT_PNT_TYPE_PNT:
BU_ALLOC(headPoint, struct pnt);
BU_LIST_INIT(&(((struct pnt *)headPoint)->l));
num_doubles_per_point = 3;
break;
case RT_PNT_TYPE_COL:
BU_ALLOC(headPoint, struct pnt_color);
BU_LIST_INIT(&(((struct pnt_color *)headPoint)->l));
num_doubles_per_point = 6;
break;
case RT_PNT_TYPE_SCA:
BU_ALLOC(headPoint, struct pnt_scale);
BU_LIST_INIT(&(((struct pnt_scale *)headPoint)->l));
num_doubles_per_point = 4;
break;
case RT_PNT_TYPE_NRM:
BU_ALLOC(headPoint, struct pnt_normal);
BU_LIST_INIT(&(((struct pnt_normal *)headPoint)->l));
num_doubles_per_point = 6;
break;
case RT_PNT_TYPE_COL_SCA:
BU_ALLOC(headPoint, struct pnt_color_scale);
BU_LIST_INIT(&(((struct pnt_color_scale *)headPoint)->l));
num_doubles_per_point = 7;
break;
case RT_PNT_TYPE_COL_NRM:
BU_ALLOC(headPoint, struct pnt_color_normal);
BU_LIST_INIT(&(((struct pnt_color_normal *)headPoint)->l));
num_doubles_per_point = 9;
break;
case RT_PNT_TYPE_SCA_NRM:
BU_ALLOC(headPoint, struct pnt_scale_normal);
BU_LIST_INIT(&(((struct pnt_scale_normal *)headPoint)->l));
num_doubles_per_point = 7;
break;
case RT_PNT_TYPE_COL_SCA_NRM:
BU_ALLOC(headPoint, struct pnt_color_scale_normal);
BU_LIST_INIT(&(((struct pnt_color_scale_normal *)headPoint)->l));
num_doubles_per_point = 10;
break;
}
BU_ASSERT_PTR(headPoint, !=, NULL);
pnts->point = headPoint;
if ((fp=fopen(argv[2], "rb")) == NULL) {
bu_vls_printf(gedp->ged_result_str, "Make '%s' failed. ", argv[1]);
bu_vls_printf(gedp->ged_result_str, "Could not open file '%s'.\n", argv[2]);
bu_vls_free(&format_string);
rt_db_free_internal(&internal);
return GED_ERROR;
}
while (!found_eof) {
/* points_loop */
/* allocate memory for single point structure for current point-cloud type */
switch (type) {
case RT_PNT_TYPE_PNT:
BU_ALLOC(point, struct pnt);
break;
case RT_PNT_TYPE_COL:
BU_ALLOC(point, struct pnt_color);
break;
case RT_PNT_TYPE_SCA:
BU_ALLOC(point, struct pnt_scale);
break;
case RT_PNT_TYPE_NRM:
BU_ALLOC(point, struct pnt_normal);
break;
case RT_PNT_TYPE_COL_SCA:
BU_ALLOC(point, struct pnt_color_scale);
break;
case RT_PNT_TYPE_COL_NRM:
BU_ALLOC(point, struct pnt_color_normal);
break;
case RT_PNT_TYPE_SCA_NRM:
BU_ALLOC(point, struct pnt_scale_normal);
break;
case RT_PNT_TYPE_COL_SCA_NRM:
BU_ALLOC(point, struct pnt_color_scale_normal);
break;
}
/* make sure we have something */
BU_ASSERT_PTR(point, !=, NULL);
while (!found_eof && !done_processing_format_string) {
/* format_string_loop */
char format = '\0';
while (!found_eof && !found_double) {
/* find_doubles_loop */
format = bu_vls_addr(&format_string)[format_string_index];
buf = fgetc(fp);
num_characters_read_from_file++;
if (feof(fp)) {
if (ferror(fp)) {
perror("ERROR: Problem reading file, system error message");
fclose(fp);
bu_vls_printf(gedp->ged_result_str, "Make '%s' failed. ", argv[1]);
bu_vls_printf(gedp->ged_result_str, "Unable to read file at byte '%lu'.\n", num_characters_read_from_file);
bu_vls_free(&format_string);
rt_db_free_internal(&internal);
return GED_ERROR;
} else {
found_eof = 1;
}
}
if (found_eof) {
fclose(fp);
current_character_double = 0;
if (num_doubles_read == 0) {
bu_vls_printf(gedp->ged_result_str, "Make '%s' failed. ", argv[1]);
bu_vls_printf(gedp->ged_result_str, "No data in file '%s'.\n", argv[2]);
bu_vls_free(&format_string);
rt_db_free_internal(&internal);
return GED_ERROR;
}
} else {
temp_char_ptr = strchr("0123456789.+-eE", buf);
if (temp_char_ptr != NULL) {
/* character read is part of a double */
current_character_double = 1;
} else {
current_character_double = 0;
}
}
if (previous_character_double && current_character_double) {
if (temp_string_index >= temp_string_size) {
fclose(fp);
bu_vls_printf(gedp->ged_result_str, "Make '%s' failed. ", argv[1]);
bu_vls_printf(gedp->ged_result_str, "String representing double too large, exceeds '%d' character limit. ", temp_string_size - 1);
report_import_error_location(num_doubles_read, num_doubles_per_point, start_offset_of_current_double,
format, gedp->ged_result_str);
bu_vls_free(&format_string);
rt_db_free_internal(&internal);
return GED_ERROR;
}
temp_string[temp_string_index] = (char)buf;
temp_string_index++;
}
if (previous_character_double && !current_character_double) {
if (temp_string_index >= temp_string_size) {
fclose(fp);
bu_vls_printf(gedp->ged_result_str, "Make '%s' failed. ", argv[1]);
bu_vls_printf(gedp->ged_result_str, "String representing double too large, exceeds '%d' character limit. ", temp_string_size - 1);
report_import_error_location(num_doubles_read, num_doubles_per_point, start_offset_of_current_double,
format, gedp->ged_result_str);
bu_vls_free(&format_string);
rt_db_free_internal(&internal);
return GED_ERROR;
}
temp_string[temp_string_index] = '\0';
/* do not convert string to double for format character '?' */
if (format != '?') {
temp_double = strtod(temp_string, &endp);
if (!((endp != temp_string) && (*endp == '\0'))) {
fclose(fp);
bu_vls_printf(gedp->ged_result_str, "Make '%s' failed. ", argv[1]);
bu_vls_printf(gedp->ged_result_str, "Unable to convert string '%s' to double. ", temp_string);
report_import_error_location(num_doubles_read, num_doubles_per_point, start_offset_of_current_double,
format, gedp->ged_result_str);
bu_vls_free(&format_string);
rt_db_free_internal(&internal);
return GED_ERROR;
}
num_doubles_read++;
} else {
temp_double = 0.0;
}
temp_string_index = 0;
found_double = 1;
previous_character_double = current_character_double;
}
if (!previous_character_double && current_character_double) {
temp_string[temp_string_index] = (char)buf;
temp_string_index++;
start_offset_of_current_double = num_characters_read_from_file;
previous_character_double = current_character_double;
}
} /* loop exits when eof encountered (and/or) double found */
if (found_double) {
/* insert double into point structure for current point-cloud type */
/* do not attempt to insert double into point structure for format character '?' */
if (format != '?') {
switch (type) {
case RT_PNT_TYPE_PNT:
INSERT_COORDINATE_INTO_STRUCTURE(pnt, format, (temp_double * local2base));
break;
case RT_PNT_TYPE_COL:
INSERT_COORDINATE_INTO_STRUCTURE(pnt_color, format, (temp_double * local2base));
INSERT_COLOR_INTO_STRUCTURE(pnt_color, format, temp_double);
break;
case RT_PNT_TYPE_SCA:
INSERT_COORDINATE_INTO_STRUCTURE(pnt_scale, format, (temp_double * local2base));
INSERT_SCALE_INTO_STRUCTURE(pnt_scale, format, (temp_double * local2base));
break;
case RT_PNT_TYPE_NRM:
INSERT_COORDINATE_INTO_STRUCTURE(pnt_normal, format, (temp_double * local2base));
INSERT_NORMAL_INTO_STRUCTURE(pnt_normal, format, (temp_double * local2base));
break;
case RT_PNT_TYPE_COL_SCA:
INSERT_COORDINATE_INTO_STRUCTURE(pnt_color_scale, format, (temp_double * local2base));
INSERT_COLOR_INTO_STRUCTURE(pnt_color_scale, format, temp_double);
INSERT_SCALE_INTO_STRUCTURE(pnt_color_scale, format, (temp_double * local2base));
break;
case RT_PNT_TYPE_COL_NRM:
INSERT_COORDINATE_INTO_STRUCTURE(pnt_color_normal, format, (temp_double * local2base));
INSERT_COLOR_INTO_STRUCTURE(pnt_color_normal, format, temp_double);
INSERT_NORMAL_INTO_STRUCTURE(pnt_color_normal, format, (temp_double * local2base));
break;
case RT_PNT_TYPE_SCA_NRM:
INSERT_COORDINATE_INTO_STRUCTURE(pnt_scale_normal, format, (temp_double * local2base));
INSERT_SCALE_INTO_STRUCTURE(pnt_scale_normal, format, (temp_double * local2base));
INSERT_NORMAL_INTO_STRUCTURE(pnt_scale_normal, format, (temp_double * local2base));
break;
case RT_PNT_TYPE_COL_SCA_NRM:
INSERT_COORDINATE_INTO_STRUCTURE(pnt_color_scale_normal, format, (temp_double * local2base));
INSERT_COLOR_INTO_STRUCTURE(pnt_color_scale_normal, format, temp_double);
INSERT_SCALE_INTO_STRUCTURE(pnt_color_scale_normal, format, (temp_double * local2base));
INSERT_NORMAL_INTO_STRUCTURE(pnt_color_scale_normal, format, (temp_double * local2base));
break;
}
}
found_double = 0; /* allows loop to continue */
format_string_index++;
if (format_string_index >= bu_vls_strlen(&format_string)) {
done_processing_format_string = 1;
}
}
} /* loop exits when eof encountered (and/or) all doubles for
* a single point are stored in point structure
*/
if (done_processing_format_string) {
/* push single point structure onto linked-list of points
* which makeup the point-cloud.
*/
switch (type) {
case RT_PNT_TYPE_PNT:
BU_LIST_PUSH(&(((struct pnt *)headPoint)->l), &((struct pnt *)point)->l);
break;
case RT_PNT_TYPE_COL:
BU_LIST_PUSH(&(((struct pnt_color *)headPoint)->l), &((struct pnt_color *)point)->l);
break;
case RT_PNT_TYPE_SCA:
BU_LIST_PUSH(&(((struct pnt_scale *)headPoint)->l), &((struct pnt_scale *)point)->l);
break;
case RT_PNT_TYPE_NRM:
BU_LIST_PUSH(&(((struct pnt_normal *)headPoint)->l), &((struct pnt_normal *)point)->l);
break;
case RT_PNT_TYPE_COL_SCA:
BU_LIST_PUSH(&(((struct pnt_color_scale *)headPoint)->l), &((struct pnt_color_scale *)point)->l);
break;
case RT_PNT_TYPE_COL_NRM:
BU_LIST_PUSH(&(((struct pnt_color_normal *)headPoint)->l), &((struct pnt_color_normal *)point)->l);
break;
case RT_PNT_TYPE_SCA_NRM:
BU_LIST_PUSH(&(((struct pnt_scale_normal *)headPoint)->l), &((struct pnt_scale_normal *)point)->l);
break;
case RT_PNT_TYPE_COL_SCA_NRM:
BU_LIST_PUSH(&(((struct pnt_color_scale_normal *)headPoint)->l), &((struct pnt_color_scale_normal *)point)->l);
break;
}
numPoints++;
format_string_index = 0;
done_processing_format_string = 0;
}
} /* loop exits when eof encountered */
if (num_doubles_read < num_doubles_per_point) {
bu_vls_printf(gedp->ged_result_str, "Make '%s' failed. Number of values read inconsistent with point-cloud type ", argv[1]);
bu_vls_printf(gedp->ged_result_str, "defined by format string '%V'. The number of values read must be an even ", format_string);
bu_vls_printf(gedp->ged_result_str, "multiple of %d but read %lu values.\n", num_doubles_per_point, num_doubles_read);
bu_vls_free(&format_string);
rt_db_free_internal(&internal);
return GED_ERROR;
}
if (num_doubles_read % num_doubles_per_point) {
bu_vls_printf(gedp->ged_result_str, "Make '%s' failed. Number of values read inconsistent with point-cloud type ", argv[1]);
bu_vls_printf(gedp->ged_result_str, "defined by format string '%V'. The number of values read must be an even ", format_string);
bu_vls_printf(gedp->ged_result_str, "multiple of %d but read %lu values.\n", num_doubles_per_point, num_doubles_read);
bu_vls_free(&format_string);
rt_db_free_internal(&internal);
return GED_ERROR;
}
pnts->count = numPoints;
GED_DB_DIRADD(gedp, dp, argv[1], RT_DIR_PHONY_ADDR, 0, RT_DIR_SOLID, (void *)&internal.idb_type, GED_ERROR);
GED_DB_PUT_INTERNAL(gedp, dp, &internal, &rt_uniresource, GED_ERROR);
bu_vls_free(&format_string);
bu_vls_printf(gedp->ged_result_str, "Make '%s' success, %lu values read, %lu points imported.\n", argv[1], num_doubles_read, numPoints);
return GED_OK;
}
int
wdb_comb_std_cmd(struct rt_wdb *wdbp,
Tcl_Interp *interp,
int argc,
char *argv[])
{
char *comb_name;
int ch;
int region_flag = -1;
struct directory *dp;
struct rt_db_internal intern;
struct rt_comb_internal *comb = NULL;
struct tokens tok_hd;
short last_tok;
int i;
union tree *final_tree;
if (wdbp->dbip->dbi_read_only) {
Tcl_AppendResult(interp, "Database is read-only!\n", (char *)NULL);
return TCL_ERROR;
}
if (argc < 3) {
struct bu_vls vls = BU_VLS_INIT_ZERO;
bu_vls_printf(&vls, "helplib_alias wdb_comb_std %s", argv[0]);
Tcl_Eval(interp, bu_vls_addr(&vls));
bu_vls_free(&vls);
return TCL_ERROR;
}
/* Parse options */
bu_optind = 1; /* re-init bu_getopt() */
while ((ch = bu_getopt(argc, argv, "cgr?")) != -1) {
switch (ch) {
case 'c':
case 'g':
region_flag = 0;
break;
case 'r':
region_flag = 1;
break;
/* XXX How about -p and -v for FASTGEN? */
case '?':
default:
PRINT_USAGE;
return TCL_OK;
}
}
argc -= (bu_optind + 1);
argv += bu_optind;
comb_name = *argv++;
if (argc == -1) {
PRINT_USAGE;
return TCL_OK;
}
if ((region_flag != -1) && (argc == 0)) {
/*
* Set/Reset the REGION flag of an existing combination
*/
if ((dp = db_lookup(wdbp->dbip, comb_name, LOOKUP_NOISY)) == RT_DIR_NULL)
return TCL_ERROR;
if (!(dp->d_flags & RT_DIR_COMB)) {
Tcl_AppendResult(interp, comb_name, " is not a combination\n", (char *)0);
return TCL_ERROR;
}
if (rt_db_get_internal(&intern, dp, wdbp->dbip, (fastf_t *)NULL, &rt_uniresource) < 0) {
Tcl_AppendResult(interp, "Database read error, aborting\n", (char *)NULL);
return TCL_ERROR;
}
comb = (struct rt_comb_internal *)intern.idb_ptr;
RT_CK_COMB(comb);
if (region_flag) {
if (!comb->region_flag) {
/* assign values from the defaults */
comb->region_id = wdbp->wdb_item_default++;
comb->aircode = wdbp->wdb_air_default;
comb->GIFTmater = wdbp->wdb_mat_default;
comb->los = wdbp->wdb_los_default;
}
comb->region_flag = 1;
} else
comb->region_flag = 0;
if (rt_db_put_internal(dp, wdbp->dbip, &intern, &rt_uniresource) < 0) {
rt_db_free_internal(&intern);
Tcl_AppendResult(interp, "Database write error, aborting\n", (char *)NULL);
return TCL_ERROR;
}
return TCL_OK;
}
/*
* At this point, we know we have a Boolean expression.
* If the combination already existed and region_flag is -1,
* then leave its region_flag alone.
* If the combination didn't exist yet,
* then pretend region_flag was 0.
* Otherwise, make sure to set its c_flags according to region_flag.
*/
dp = db_lookup(wdbp->dbip, comb_name, LOOKUP_QUIET);
if (dp != RT_DIR_NULL) {
Tcl_AppendResult(interp, "ERROR: ", comb_name, " already exists\n", (char *)0);
return TCL_ERROR;
}
/* parse Boolean expression */
BU_LIST_INIT(&tok_hd.l);
tok_hd.type = WDB_TOK_NULL;
last_tok = WDB_TOK_LPAREN;
for (i = 0; i < argc; i++) {
char *ptr;
ptr = argv[i];
while (*ptr) {
while (*ptr == '(' || *ptr == ')') {
switch (*ptr) {
case '(':
wdb_append_lparen(&tok_hd.l);
last_tok = WDB_TOK_LPAREN;
break;
case ')':
wdb_append_rparen(&tok_hd.l);
last_tok = WDB_TOK_RPAREN;
break;
}
ptr++;
}
if (*ptr == '\0')
continue;
if (last_tok == WDB_TOK_RPAREN) {
/* next token MUST be an operator */
if (wdb_add_operator(interp, &tok_hd.l, *ptr, &last_tok) == TCL_ERROR) {
wdb_free_tokens(&tok_hd.l);
return TCL_ERROR;
}
ptr++;
} else if (last_tok == WDB_TOK_LPAREN) {
/* next token MUST be an operand */
int name_len;
name_len = wdb_add_operand(interp, &tok_hd.l, ptr);
if (name_len < 1) {
wdb_free_tokens(&tok_hd.l);
return TCL_ERROR;
}
last_tok = WDB_TOK_TREE;
ptr += name_len;
} else if (last_tok == WDB_TOK_TREE) {
/* must be an operator */
if (wdb_add_operator(interp, &tok_hd.l, *ptr, &last_tok) == TCL_ERROR) {
wdb_free_tokens(&tok_hd.l);
return TCL_ERROR;
}
ptr++;
} else if (last_tok == WDB_TOK_UNION ||
last_tok == WDB_TOK_INTER ||
last_tok == WDB_TOK_SUBTR) {
/* must be an operand */
int name_len;
name_len = wdb_add_operand(interp, &tok_hd.l, ptr);
if (name_len < 1) {
wdb_free_tokens(&tok_hd.l);
return TCL_ERROR;
}
last_tok = WDB_TOK_TREE;
ptr += name_len;
}
}
}
if (wdb_check_syntax(interp, wdbp->dbip, &tok_hd.l, comb_name, dp)) {
wdb_free_tokens(&tok_hd.l);
return TCL_ERROR;
}
final_tree = wdb_eval_bool(&tok_hd.l);
{
int flags;
flags = RT_DIR_COMB;
BU_ALLOC(comb, struct rt_comb_internal);
RT_COMB_INTERNAL_INIT(comb);
comb->tree = final_tree;
comb->region_id = -1;
if (region_flag == (-1))
comb->region_flag = 0;
else
comb->region_flag = region_flag;
if (comb->region_flag) {
struct bu_vls tmp_vls = BU_VLS_INIT_ZERO;
comb->region_flag = 1;
comb->region_id = wdbp->wdb_item_default++;;
comb->aircode = wdbp->wdb_air_default;
comb->los = wdbp->wdb_los_default;
comb->GIFTmater = wdbp->wdb_mat_default;
bu_vls_printf(&tmp_vls,
"Creating region id=%ld, air=%ld, los=%ld, GIFTmaterial=%ld\n",
comb->region_id, comb->aircode, comb->los, comb->GIFTmater);
Tcl_AppendResult(interp, bu_vls_addr(&tmp_vls), (char *)NULL);
bu_vls_free(&tmp_vls);
flags |= RT_DIR_REGION;
}
RT_DB_INTERNAL_INIT(&intern);
intern.idb_major_type = DB5_MAJORTYPE_BRLCAD;
intern.idb_type = ID_COMBINATION;
intern.idb_meth = &rt_functab[ID_COMBINATION];
intern.idb_ptr = (genptr_t)comb;
dp=db_diradd(wdbp->dbip, comb_name, RT_DIR_PHONY_ADDR, 0, flags, (genptr_t)&intern.idb_type);
if (dp == RT_DIR_NULL) {
Tcl_AppendResult(interp, "Failed to add ", comb_name,
" to directory, aborting\n", (char *)NULL);
return TCL_ERROR;
}
if (rt_db_put_internal(dp, wdbp->dbip, &intern, &rt_uniresource) < 0) {
Tcl_AppendResult(interp, "Failed to write ", dp->d_namep, (char *)NULL);
return TCL_ERROR;
}
}
return TCL_OK;
}
int
ged_bev(struct ged *gedp, int argc, const char *argv[])
{
static const char *usage = "[P|t] new_obj obj1 op obj2 op obj3 ...";
int i;
int c;
int ncpu;
char *cmdname;
char *newname;
struct rt_db_internal intern;
struct directory *dp;
char op;
int failed;
/* static due to longjmp */
static int triangulate = 0;
static union tree *tmp_tree = NULL;
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 < 3) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
cmdname = (char *)argv[0];
/* Establish tolerances */
gedp->ged_wdbp->wdb_initial_tree_state.ts_ttol = &gedp->ged_wdbp->wdb_ttol;
gedp->ged_wdbp->wdb_initial_tree_state.ts_tol = &gedp->ged_wdbp->wdb_tol;
gedp->ged_wdbp->wdb_ttol.magic = RT_TESS_TOL_MAGIC;
/* Initial values for options, must be reset each time */
ncpu = 1;
triangulate = 0;
/* Parse options. */
bu_optind = 1; /* re-init bu_getopt() */
while ((c=bu_getopt(argc, (char * const *)argv, "tP:")) != -1) {
switch (c) {
case 'P':
#if 0
/* not yet supported */
ncpu = atoi(bu_optarg);
#endif
break;
case 't':
triangulate = 1;
break;
default: {
bu_vls_printf(gedp->ged_result_str, "%s: option '%c' unknown\n", cmdname, c);
}
break;
}
}
argc -= bu_optind;
argv += bu_optind;
newname = (char *)argv[0];
argv++;
argc--;
if (argc < 1) {
bu_vls_printf(gedp->ged_result_str, "%s: Nothing to evaluate!!!\n", cmdname);
return GED_ERROR;
}
GED_CHECK_EXISTS(gedp, newname, LOOKUP_QUIET, GED_ERROR);
bu_vls_printf(gedp->ged_result_str,
"%s: tessellating primitives with tolerances a=%g, r=%g, n=%g\n",
argv[0],
gedp->ged_wdbp->wdb_ttol.abs,
gedp->ged_wdbp->wdb_ttol.rel,
gedp->ged_wdbp->wdb_ttol.norm);
bev_facetize_tree = (union tree *)0;
bev_nmg_model = nmg_mm();
gedp->ged_wdbp->wdb_initial_tree_state.ts_m = &bev_nmg_model;
op = ' ';
tmp_tree = (union tree *)NULL;
while (argc) {
i = db_walk_tree(gedp->ged_wdbp->dbip, 1, (const char **)argv,
ncpu,
&gedp->ged_wdbp->wdb_initial_tree_state,
0, /* take all regions */
bev_facetize_region_end,
nmg_booltree_leaf_tess,
(genptr_t)gedp);
if (i < 0) {
bu_vls_printf(gedp->ged_result_str, "%s: error in db_walk_tree()\n", cmdname);
/* Destroy NMG */
nmg_km(bev_nmg_model);
return GED_ERROR;
}
argc--;
argv++;
if (tmp_tree && op != ' ') {
union tree *new_tree;
BU_ALLOC(new_tree, union tree);
RT_TREE_INIT(new_tree);
new_tree->tr_b.tb_regionp = REGION_NULL;
new_tree->tr_b.tb_left = tmp_tree;
new_tree->tr_b.tb_right = bev_facetize_tree;
switch (op) {
case 'u':
case 'U':
new_tree->tr_op = OP_UNION;
break;
case '-':
new_tree->tr_op = OP_SUBTRACT;
break;
case '+':
new_tree->tr_op = OP_INTERSECT;
break;
default: {
bu_vls_printf(gedp->ged_result_str, "%s: Unrecognized operator: (%c)\nAborting\n",
argv[0], op);
db_free_tree(bev_facetize_tree, &rt_uniresource);
nmg_km(bev_nmg_model);
return GED_ERROR;
}
}
tmp_tree = new_tree;
bev_facetize_tree = (union tree *)NULL;
} else if (!tmp_tree && op == ' ') {
/* just starting out */
tmp_tree = bev_facetize_tree;
bev_facetize_tree = (union tree *)NULL;
}
if (argc) {
op = *argv[0];
argc--;
argv++;
} else
op = ' ';
}
if (tmp_tree) {
/* Now, evaluate the boolean tree into ONE region */
bu_vls_printf(gedp->ged_result_str, "%s: evaluating boolean expressions\n", cmdname);
if (BU_SETJUMP) {
BU_UNSETJUMP;
bu_vls_printf(gedp->ged_result_str, "%s: WARNING: Boolean evaluation failed!!!\n", cmdname);
if (tmp_tree)
db_free_tree(tmp_tree, &rt_uniresource);
tmp_tree = (union tree *)NULL;
nmg_km(bev_nmg_model);
bev_nmg_model = (struct model *)NULL;
return GED_ERROR;
}
failed = nmg_boolean(tmp_tree, bev_nmg_model, &gedp->ged_wdbp->wdb_tol, &rt_uniresource);
BU_UNSETJUMP;
} else
failed = 1;
if (failed) {
bu_vls_printf(gedp->ged_result_str, "%s: no resulting region, aborting\n", cmdname);
if (tmp_tree)
db_free_tree(tmp_tree, &rt_uniresource);
tmp_tree = (union tree *)NULL;
nmg_km(bev_nmg_model);
bev_nmg_model = (struct model *)NULL;
return GED_ERROR;
}
/* New region remains part of this nmg "model" */
NMG_CK_REGION(tmp_tree->tr_d.td_r);
bu_vls_printf(gedp->ged_result_str, "%s: facetize %s\n", cmdname, tmp_tree->tr_d.td_name);
nmg_vmodel(bev_nmg_model);
/* Triangulate model, if requested */
if (triangulate) {
bu_vls_printf(gedp->ged_result_str, "%s: triangulating resulting object\n", cmdname);
if (BU_SETJUMP) {
BU_UNSETJUMP;
bu_vls_printf(gedp->ged_result_str, "%s: WARNING: Triangulation failed!!!\n", cmdname);
if (tmp_tree)
db_free_tree(tmp_tree, &rt_uniresource);
tmp_tree = (union tree *)NULL;
nmg_km(bev_nmg_model);
bev_nmg_model = (struct model *)NULL;
return GED_ERROR;
}
nmg_triangulate_model(bev_nmg_model, &gedp->ged_wdbp->wdb_tol);
BU_UNSETJUMP;
}
bu_vls_printf(gedp->ged_result_str, "%s: converting NMG to database format\n", cmdname);
/* Export NMG as a new solid */
RT_DB_INTERNAL_INIT(&intern);
intern.idb_major_type = DB5_MAJORTYPE_BRLCAD;
intern.idb_type = ID_NMG;
intern.idb_meth = &rt_functab[ID_NMG];
intern.idb_ptr = (genptr_t)bev_nmg_model;
bev_nmg_model = (struct model *)NULL;
GED_DB_DIRADD(gedp, dp, newname, RT_DIR_PHONY_ADDR, 0, RT_DIR_SOLID, (genptr_t)&intern.idb_type, GED_ERROR);
GED_DB_PUT_INTERNAL(gedp, dp, &intern, &rt_uniresource, GED_ERROR);
tmp_tree->tr_d.td_r = (struct nmgregion *)NULL;
/* Free boolean tree, and the regions in it. */
db_free_tree(tmp_tree, &rt_uniresource);
return GED_OK;
}
int
ged_facetize(struct ged *gedp, int argc, const char *argv[])
{
int i;
int c;
char *newname;
struct rt_db_internal intern;
struct directory *dp;
int failed;
int nmg_use_tnurbs = 0;
struct db_tree_state init_state;
struct db_i *dbip;
union tree *facetize_tree;
struct model *nmg_model;
static const char *usage = "[ [-P] | [-n] [-t] [-T] ] new_obj old_obj [old_obj2 old_obj3 ...]";
/* static due to jumping */
static int triangulate;
static int make_bot;
static int marching_cube;
static int screened_poisson;
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 < 3) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
dbip = gedp->ged_wdbp->dbip;
RT_CHECK_DBI(dbip);
db_init_db_tree_state(&init_state, dbip, gedp->ged_wdbp->wdb_resp);
/* Establish tolerances */
init_state.ts_ttol = &gedp->ged_wdbp->wdb_ttol;
init_state.ts_tol = &gedp->ged_wdbp->wdb_tol;
/* Initial values for options, must be reset each time */
marching_cube = 0;
screened_poisson = 0;
triangulate = 0;
make_bot = 1;
/* Parse options. */
bu_optind = 1; /* re-init bu_getopt() */
while ((c=bu_getopt(argc, (char * const *)argv, "mntTP")) != -1) {
switch (c) {
case 'm':
marching_cube = triangulate = 1;
/* no break, marching cubes assumes nmg for now */
case 'n':
make_bot = 0;
break;
case 'P':
screened_poisson = 1;
triangulate = 1;
make_bot = 1;
break;
case 'T':
triangulate = 1;
break;
case 't':
nmg_use_tnurbs = 1;
break;
default: {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
}
}
argc -= bu_optind;
argv += bu_optind;
if (argc < 0) {
bu_vls_printf(gedp->ged_result_str, "facetize: missing argument\n");
return GED_ERROR;
}
if (screened_poisson && (marching_cube || !make_bot || nmg_use_tnurbs)) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
newname = (char *)argv[0];
argv++;
argc--;
if (argc < 0) {
bu_vls_printf(gedp->ged_result_str, "facetize: missing argument\n");
return GED_ERROR;
}
if (db_lookup(dbip, newname, LOOKUP_QUIET) != RT_DIR_NULL) {
bu_vls_printf(gedp->ged_result_str, "error: solid '%s' already exists, aborting\n", newname);
return GED_ERROR;
}
if (screened_poisson) {
struct rt_bot_internal *bot;
BU_ALLOC(bot, struct rt_bot_internal);
bot->magic = RT_BOT_INTERNAL_MAGIC;
bot->mode = RT_BOT_SOLID;
bot->orientation = RT_BOT_UNORIENTED;
bot->thickness = (fastf_t *)NULL;
bot->face_mode = (struct bu_bitv *)NULL;
/* TODO - generate point cloud, then mesh - need to see the input points for debugging */
(void)rt_generate_mesh(&(bot->faces), (int *)&(bot->num_faces), (point_t **)&(bot->vertices), (int *)&(bot->num_vertices),
dbip, argv[0], 15);
/* Export BOT as a new solid */
RT_DB_INTERNAL_INIT(&intern);
intern.idb_major_type = DB5_MAJORTYPE_BRLCAD;
intern.idb_type = ID_BOT;
intern.idb_meth = &OBJ[ID_BOT];
intern.idb_ptr = (void *) bot;
} else {
bu_vls_printf(gedp->ged_result_str,
"facetize: tessellating primitives with tolerances a=%g, r=%g, n=%g\n",
gedp->ged_wdbp->wdb_ttol.abs, gedp->ged_wdbp->wdb_ttol.rel, gedp->ged_wdbp->wdb_ttol.norm);
facetize_tree = (union tree *)0;
nmg_model = nmg_mm();
init_state.ts_m = &nmg_model;
i = db_walk_tree(dbip, argc, (const char **)argv,
1,
&init_state,
0, /* take all regions */
facetize_region_end,
nmg_use_tnurbs ?
nmg_booltree_leaf_tnurb :
nmg_booltree_leaf_tess,
(void *)&facetize_tree
);
if (i < 0) {
bu_vls_printf(gedp->ged_result_str, "facetize: error in db_walk_tree()\n");
/* Destroy NMG */
nmg_km(nmg_model);
return GED_ERROR;
}
if (facetize_tree) {
/* Now, evaluate the boolean tree into ONE region */
bu_vls_printf(gedp->ged_result_str, "facetize: evaluating boolean expressions\n");
if (!BU_SETJUMP) {
/* try */
failed = nmg_boolean(facetize_tree, nmg_model, &gedp->ged_wdbp->wdb_tol, &rt_uniresource);
} else {
/* catch */
BU_UNSETJUMP;
bu_vls_printf(gedp->ged_result_str, "WARNING: facetization failed!!!\n");
db_free_tree(facetize_tree, &rt_uniresource);
facetize_tree = (union tree *)NULL;
nmg_km(nmg_model);
nmg_model = (struct model *)NULL;
return GED_ERROR;
} BU_UNSETJUMP;
} else
failed = 1;
if (failed) {
bu_vls_printf(gedp->ged_result_str, "facetize: no resulting region, aborting\n");
db_free_tree(facetize_tree, &rt_uniresource);
facetize_tree = (union tree *)NULL;
nmg_km(nmg_model);
nmg_model = (struct model *)NULL;
return GED_ERROR;
}
/* New region remains part of this nmg "model" */
NMG_CK_REGION(facetize_tree->tr_d.td_r);
bu_vls_printf(gedp->ged_result_str, "facetize: %s\n", facetize_tree->tr_d.td_name);
/* Triangulate model, if requested */
if (triangulate && !make_bot) {
bu_vls_printf(gedp->ged_result_str, "facetize: triangulating resulting object\n");
if (!BU_SETJUMP) {
/* try */
if (marching_cube == 1)
nmg_triangulate_model_mc(nmg_model, &gedp->ged_wdbp->wdb_tol);
else
nmg_triangulate_model(nmg_model, &gedp->ged_wdbp->wdb_tol);
} else {
/* catch */
BU_UNSETJUMP;
bu_vls_printf(gedp->ged_result_str, "WARNING: triangulation failed!!!\n");
db_free_tree(facetize_tree, &rt_uniresource);
facetize_tree = (union tree *)NULL;
nmg_km(nmg_model);
nmg_model = (struct model *)NULL;
return GED_ERROR;
} BU_UNSETJUMP;
}
if (make_bot) {
struct rt_bot_internal *bot;
struct nmgregion *r;
struct shell *s;
bu_vls_printf(gedp->ged_result_str, "facetize: converting to BOT format\n");
/* WTF, FIXME: this is only dumping the first shell of the first region */
r = BU_LIST_FIRST(nmgregion, &nmg_model->r_hd);
if (r && BU_LIST_NEXT(nmgregion, &r->l) != (struct nmgregion *)&nmg_model->r_hd)
bu_vls_printf(gedp->ged_result_str, "WARNING: model has more than one region, only facetizing the first\n");
s = BU_LIST_FIRST(shell, &r->s_hd);
if (s && BU_LIST_NEXT(shell, &s->l) != (struct shell *)&r->s_hd)
bu_vls_printf(gedp->ged_result_str, "WARNING: model has more than one shell, only facetizing the first\n");
if (!BU_SETJUMP) {
/* try */
bot = (struct rt_bot_internal *)nmg_bot(s, &gedp->ged_wdbp->wdb_tol);
} else {
/* catch */
BU_UNSETJUMP;
bu_vls_printf(gedp->ged_result_str, "WARNING: conversion to BOT failed!\n");
db_free_tree(facetize_tree, &rt_uniresource);
facetize_tree = (union tree *)NULL;
nmg_km(nmg_model);
nmg_model = (struct model *)NULL;
return GED_ERROR;
} BU_UNSETJUMP;
nmg_km(nmg_model);
nmg_model = (struct model *)NULL;
/* Export BOT as a new solid */
RT_DB_INTERNAL_INIT(&intern);
intern.idb_major_type = DB5_MAJORTYPE_BRLCAD;
intern.idb_type = ID_BOT;
intern.idb_meth = &OBJ[ID_BOT];
intern.idb_ptr = (void *) bot;
} else {
bu_vls_printf(gedp->ged_result_str, "facetize: converting NMG to database format\n");
/* Export NMG as a new solid */
RT_DB_INTERNAL_INIT(&intern);
intern.idb_major_type = DB5_MAJORTYPE_BRLCAD;
intern.idb_type = ID_NMG;
intern.idb_meth = &OBJ[ID_NMG];
intern.idb_ptr = (void *)nmg_model;
nmg_model = (struct model *)NULL;
}
}
dp=db_diradd(dbip, newname, RT_DIR_PHONY_ADDR, 0, RT_DIR_SOLID, (void *)&intern.idb_type);
if (dp == RT_DIR_NULL) {
bu_vls_printf(gedp->ged_result_str, "Cannot add %s to directory\n", newname);
return GED_ERROR;
}
if (rt_db_put_internal(dp, dbip, &intern, &rt_uniresource) < 0) {
bu_vls_printf(gedp->ged_result_str, "Failed to write %s to database\n", newname);
rt_db_free_internal(&intern);
return GED_ERROR;
}
if (!screened_poisson) {
facetize_tree->tr_d.td_r = (struct nmgregion *)NULL;
/* Free boolean tree, and the regions in it */
db_free_tree(facetize_tree, &rt_uniresource);
facetize_tree = (union tree *)NULL;
}
return GED_OK;
}
int
ged_copyeval(struct ged *gedp, int argc, const char *argv[])
{
static const char *usage = "path_to_old_prim new_prim";
struct _ged_trace_data gtd;
struct directory *dp;
struct rt_db_internal *ip;
struct rt_db_internal internal, new_int;
char *tok;
int endpos = 0;
int i;
mat_t start_mat;
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 != 3) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
/* initialize gtd */
gtd.gtd_gedp = gedp;
gtd.gtd_flag = _GED_CPEVAL;
gtd.gtd_prflag = 0;
/* check if new solid name already exists in description */
GED_CHECK_EXISTS(gedp, argv[2], LOOKUP_QUIET, GED_ERROR);
MAT_IDN(start_mat);
/* build directory pointer array for desired path */
if (strchr(argv[1], '/')) {
tok = strtok((char *)argv[1], "/");
while (tok) {
GED_DB_LOOKUP(gedp, gtd.gtd_obj[endpos], tok, LOOKUP_NOISY, GED_ERROR & GED_QUIET);
endpos++;
tok = strtok((char *)NULL, "/");
}
} else {
GED_DB_LOOKUP(gedp, gtd.gtd_obj[endpos], argv[1], LOOKUP_NOISY, GED_ERROR & GED_QUIET);
endpos++;
}
if (endpos < 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
gtd.gtd_objpos = endpos - 1;
GED_DB_GET_INTERNAL(gedp, &internal, gtd.gtd_obj[endpos - 1], bn_mat_identity, &rt_uniresource, GED_ERROR);
if (endpos > 1) {
/* Make sure that final component in path is a solid */
if (internal.idb_type == ID_COMBINATION) {
rt_db_free_internal(&internal);
bu_vls_printf(gedp->ged_result_str, "final component on path must be a primitive!\n");
return GED_ERROR;
}
/* Accumulate the matrices */
ged_trace(gtd.gtd_obj[0], 0, start_mat, >d, 1);
if (gtd.gtd_prflag == 0) {
bu_vls_printf(gedp->ged_result_str, "PATH: ");
for (i = 0; i < gtd.gtd_objpos; i++)
bu_vls_printf(gedp->ged_result_str, "/%s", gtd.gtd_obj[i]->d_namep);
bu_vls_printf(gedp->ged_result_str, " NOT FOUND\n");
rt_db_free_internal(&internal);
return GED_ERROR;
}
/* Have found the desired path - wdb_xform is the transformation matrix */
/* wdb_xform matrix calculated in wdb_trace() */
/* create the new solid */
RT_DB_INTERNAL_INIT(&new_int);
if (rt_generic_xform(&new_int, gtd.gtd_xform,
&internal, 0, gedp->ged_wdbp->dbip, &rt_uniresource)) {
rt_db_free_internal(&internal);
bu_vls_printf(gedp->ged_result_str, "ged_copyeval: rt_generic_xform failed\n");
return GED_ERROR;
}
ip = &new_int;
} else
ip = &internal;
/* should call GED_DB_DIRADD() but need to deal with freeing the
* internals on failure.
*/
dp=db_diradd(gedp->ged_wdbp->dbip, argv[2], RT_DIR_PHONY_ADDR, 0, gtd.gtd_obj[endpos-1]->d_flags, (void *)&ip->idb_type);
if (dp == RT_DIR_NULL) {
rt_db_free_internal(&internal);
if (ip == &new_int)
rt_db_free_internal(&new_int);
bu_vls_printf(gedp->ged_result_str, "An error has occurred while adding a new object to the database.");
return GED_ERROR;
}
/* should call GED_DB_DIRADD() but need to deal with freeing the
* internals on failure.
*/
if (rt_db_put_internal(dp, gedp->ged_wdbp->dbip, ip, &rt_uniresource) < 0) {
/* if (ip == &new_int) then new_int gets freed by the rt_db_put_internal above
* regardless of whether it succeeds or not. At this point only internal needs
* to be freed. On the other hand if (ip == &internal), the internal gets freed
* freed by the rt_db_put_internal above. In this case memory for new_int has
* not been allocated.
*/
if (ip == &new_int)
rt_db_free_internal(&internal);
bu_vls_printf(gedp->ged_result_str, "Database write error, aborting");
return GED_ERROR;
}
/* see previous comment */
if (ip == &new_int)
rt_db_free_internal(&internal);
return GED_OK;
}
int
rt_mk_binunif(struct rt_wdb *wdbp, const char *obj_name, const char *file_name, unsigned int minor_type, size_t max_count)
{
int ret;
struct stat st;
size_t num_items = 0;
size_t obj_length = 0;
size_t item_length = 0;
unsigned int major_type = DB5_MAJORTYPE_BINARY_UNIF;
struct directory *dp = NULL;
struct bu_mapped_file *bu_fd = NULL;
struct rt_binunif_internal *bip = NULL;
struct bu_external body;
struct bu_external bin_ext;
struct rt_db_internal intern;
item_length = db5_type_sizeof_h_binu(minor_type);
if (item_length == 0) {
bu_log("Unrecognized minor type (%d)!\n", minor_type);
return -1;
}
if (bu_stat(file_name, &st)) {
bu_log("Cannot stat input file (%s)", file_name);
return -1;
}
bu_fd = bu_open_mapped_file(file_name, NULL);
if (bu_fd == NULL) {
bu_log("Cannot open input file (%s) for reading", file_name);
return -1;
}
/* create the rt_binunif internal form */
BU_ALLOC(bip, struct rt_binunif_internal);
bip->magic = RT_BINUNIF_INTERNAL_MAGIC;
bip->type = minor_type;
num_items = (size_t)(st.st_size / item_length);
/* maybe only a partial file read */
if (max_count > 0 && max_count < num_items) {
num_items = max_count;
}
obj_length = num_items * item_length;
if (obj_length < 1) {
obj_length = 1;
}
/* just copy the bytes */
bip->count = (long)num_items;
bip->u.int8 = (char *)bu_malloc(obj_length, "binary uniform object");
memcpy(bip->u.int8, bu_fd->buf, obj_length);
bu_close_mapped_file(bu_fd);
/* create the rt_internal form */
RT_DB_INTERNAL_INIT(&intern);
intern.idb_major_type = major_type;
intern.idb_minor_type = minor_type;
intern.idb_ptr = (genptr_t)bip;
intern.idb_meth = &rt_functab[ID_BINUNIF];
/* create body portion of external form */
ret = -1;
if (intern.idb_meth->ft_export5) {
ret = intern.idb_meth->ft_export5(&body, &intern, 1.0, wdbp->dbip, wdbp->wdb_resp);
}
if (ret != 0) {
bu_log("Error while attempting to export %s\n", obj_name);
rt_db_free_internal(&intern);
return -1;
}
/* create entire external form */
db5_export_object3(&bin_ext, DB5HDR_HFLAGS_DLI_APPLICATION_DATA_OBJECT,
obj_name, 0, NULL, &body,
intern.idb_major_type, intern.idb_minor_type,
DB5_ZZZ_UNCOMPRESSED, DB5_ZZZ_UNCOMPRESSED);
rt_db_free_internal(&intern);
bu_free_external(&body);
/* make sure the database directory is initialized */
if (wdbp->dbip->dbi_eof == RT_DIR_PHONY_ADDR) {
ret = db_dirbuild(wdbp->dbip);
if (ret) {
return -1;
}
}
/* add this (phony until written) object to the directory */
if ((dp=db_diradd5(wdbp->dbip, obj_name, RT_DIR_PHONY_ADDR, major_type,
minor_type, 0, 0, NULL)) == RT_DIR_NULL) {
bu_log("Error while attempting to add new name (%s) to the database",
obj_name);
bu_free_external(&bin_ext);
return -1;
}
/* and write it to the database */
if (db_put_external5(&bin_ext, dp, wdbp->dbip)) {
bu_log("Error while adding new binary object (%s) to the database",
obj_name);
bu_free_external(&bin_ext);
return -1;
}
bu_free_external(&bin_ext);
return 0;
}
union tree *
evaluate(union tree *tr, const struct rt_tess_tol *ttol, const struct bn_tol *tol)
{
RT_CK_TREE(tr);
switch (tr->tr_op) {
case OP_NOP:
return tr;
case OP_NMG_TESS:
/* ugh, keep it as nmg_tess and just shove the rt_bot_internal ptr
* in as nmgregion. :/ Also, only doing the first shell of the first
* model. Primitives should only provide a single shell, right? */
{
struct rt_db_internal ip;
struct nmgregion *nmgr = BU_LIST_FIRST(nmgregion, &tr->tr_d.td_r->m_p->r_hd);
/* the bot temporary format may be unnecessary if we can walk
* the nmg shells and generate soup from them directly. */
struct rt_bot_internal *bot = nmg_bot(BU_LIST_FIRST(shell, &nmgr->s_hd), tol);
/* causes a crash.
nmg_kr(nmgr);
free(nmgr);
*/
tr->tr_d.td_r->m_p = (struct model *)bot2soup(bot, tol);
SOUP_CKMAG((struct soup_s *)tr->tr_d.td_r->m_p);
/* fill in a db_internal with our new bot so we can free it */
RT_DB_INTERNAL_INIT(&ip);
ip.idb_major_type = DB5_MAJORTYPE_BRLCAD;
ip.idb_minor_type = ID_BOT;
ip.idb_meth = &OBJ[ID_BOT];
ip.idb_ptr = bot;
ip.idb_meth->ft_ifree(&ip);
}
return tr;
case OP_UNION:
case OP_INTERSECT:
case OP_SUBTRACT:
RT_CK_TREE(tr->tr_b.tb_left);
RT_CK_TREE(tr->tr_b.tb_right);
tr->tr_b.tb_left = evaluate(tr->tr_b.tb_left, ttol, tol);
tr->tr_b.tb_right = evaluate(tr->tr_b.tb_right, ttol, tol);
RT_CK_TREE(tr->tr_b.tb_left);
RT_CK_TREE(tr->tr_b.tb_right);
SOUP_CKMAG(tr->tr_b.tb_left->tr_d.td_r->m_p);
SOUP_CKMAG(tr->tr_b.tb_right->tr_d.td_r->m_p);
split_faces(tr->tr_b.tb_left, tr->tr_b.tb_right, tol);
RT_CK_TREE(tr->tr_b.tb_left);
RT_CK_TREE(tr->tr_b.tb_right);
SOUP_CKMAG(tr->tr_b.tb_left->tr_d.td_r->m_p);
SOUP_CKMAG(tr->tr_b.tb_right->tr_d.td_r->m_p);
break;
default:
bu_bomb("bottess evaluate(): bad op (first pass)\n");
}
switch (tr->tr_op) {
case OP_UNION:
return compose(tr->tr_b.tb_left, tr->tr_b.tb_right, OUTSIDE, SAME, OUTSIDE);
case OP_INTERSECT:
return compose(tr->tr_b.tb_left, tr->tr_b.tb_right, INSIDE, SAME, INSIDE);
case OP_SUBTRACT:
return invert(compose(tr->tr_b.tb_left, invert(tr->tr_b.tb_right), OUTSIDE, OPPOSITE, INSIDE));
default:
bu_bomb("bottess evaluate(): bad op (second pass, CSG)\n");
}
bu_bomb("Got somewhere I shouldn't have\n");
return NULL;
}
int
ged_make(struct ged *gedp, int argc, const char *argv[])
{
size_t i;
int k;
int save_bu_optind;
struct directory *dp;
/* intentionally double for sscanf */
double scale = 1.0;
double origin[3] = {0.0, 0.0, 0.0};
struct rt_db_internal internal;
struct rt_arb_internal *arb_ip;
struct rt_ars_internal *ars_ip;
struct rt_tgc_internal *tgc_ip;
struct rt_ell_internal *ell_ip;
struct rt_tor_internal *tor_ip;
struct rt_grip_internal *grp_ip;
struct rt_half_internal *half_ip;
struct rt_rpc_internal *rpc_ip;
struct rt_rhc_internal *rhc_ip;
struct rt_epa_internal *epa_ip;
struct rt_ehy_internal *ehy_ip;
struct rt_eto_internal *eto_ip;
struct rt_part_internal *part_ip;
struct rt_pipe_internal *pipe_ip;
struct rt_sketch_internal *sketch_ip;
struct rt_extrude_internal *extrude_ip;
struct rt_bot_internal *bot_ip;
struct rt_arbn_internal *arbn_ip;
struct rt_superell_internal *superell_ip;
struct rt_metaball_internal *metaball_ip;
struct rt_pnts_internal *pnts_ip;
static const char *usage = "-h | -t | -o origin -s sf name <arb8|arb7|arb6|arb5|arb4|arbn|ars|bot|ehy|ell|ell1|epa|eto|extrude|grip|half|hyp|nmg|part|pipe|pnts|rcc|rec|rhc|rpc|rpp|sketch|sph|tec|tgc|tor|trc>";
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;
}
bu_optind = 1;
/* Process arguments */
while ((k = bu_getopt(argc, (char * const *)argv, "hHo:O:s:S:tT")) != -1) {
switch (k) {
case 'o':
case 'O':
if (sscanf(bu_optarg, "%lf %lf %lf",
&origin[X],
&origin[Y],
&origin[Z]) != 3) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
break;
case 's':
case 'S':
if (sscanf(bu_optarg, "%lf", &scale) != 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
break;
case 't':
case 'T':
if (argc == 2) {
bu_vls_printf(gedp->ged_result_str, "arb8 arb7 arb6 arb5 arb4 arbn ars bot ehy ell ell1 epa eto extrude grip half hyp nmg part pipe pnts rcc rec rhc rpc rpp sketch sph tec tgc tor trc superell metaball");
return GED_HELP;
}
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
case 'h':
case 'H':
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_HELP;
default:
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
}
argc -= bu_optind;
if (argc != 2) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
save_bu_optind = bu_optind;
GED_CHECK_EXISTS(gedp, argv[bu_optind], LOOKUP_QUIET, GED_ERROR);
RT_DB_INTERNAL_INIT(&internal);
if (BU_STR_EQUAL(argv[bu_optind+1], "arb8") ||
BU_STR_EQUAL(argv[bu_optind+1], "rpp")) {
internal.idb_major_type = DB5_MAJORTYPE_BRLCAD;
internal.idb_type = ID_ARB8;
internal.idb_meth = &OBJ[ID_ARB8];
BU_ALLOC(internal.idb_ptr, struct rt_arb_internal);
arb_ip = (struct rt_arb_internal *)internal.idb_ptr;
arb_ip->magic = RT_ARB_INTERNAL_MAGIC;
VSET(arb_ip->pt[0] ,
origin[X] + 0.5*scale,
origin[Y] - 0.5*scale,
origin[Z] - 0.5*scale);
for (i = 1; i < 8; i++)
VMOVE(arb_ip->pt[i], arb_ip->pt[0]);
arb_ip->pt[1][Y] += scale;
arb_ip->pt[2][Y] += scale;
arb_ip->pt[2][Z] += scale;
arb_ip->pt[3][Z] += scale;
for (i = 4; i < 8; i++)
arb_ip->pt[i][X] -= scale;
arb_ip->pt[5][Y] += scale;
arb_ip->pt[6][Y] += scale;
arb_ip->pt[6][Z] += scale;
arb_ip->pt[7][Z] += scale;
} else if (BU_STR_EQUAL(argv[bu_optind+1], "arb7")) {
extern "C" void
rt_revolve_brep(ON_Brep **b, const struct rt_db_internal *ip, const struct bn_tol *tol)
{
struct rt_db_internal *tmp_internal;
struct rt_revolve_internal *rip;
struct rt_sketch_internal *eip;
BU_ALLOC(tmp_internal, struct rt_db_internal);
RT_DB_INTERNAL_INIT(tmp_internal);
rip = (struct rt_revolve_internal *)ip->idb_ptr;
RT_REVOLVE_CK_MAGIC(rip);
eip = rip->skt;
RT_SKETCH_CK_MAGIC(eip);
ON_3dPoint plane_origin;
ON_3dVector plane_x_dir, plane_y_dir;
bool full_revolve = true;
if (rip->ang < 2*ON_PI && rip->ang > 0)
full_revolve = false;
// Find plane in 3 space corresponding to the sketch.
vect_t startpoint;
VADD2(startpoint, rip->v3d, rip->r);
plane_origin = ON_3dPoint(startpoint);
plane_x_dir = ON_3dVector(eip->u_vec);
plane_y_dir = ON_3dVector(eip->v_vec);
const ON_Plane sketch_plane = ON_Plane(plane_origin, plane_x_dir, plane_y_dir);
// For the brep, need the list of 3D vertex points. In sketch, they
// are stored as 2D coordinates, so use the sketch_plane to define 3 space
// points for the vertices.
for (size_t i = 0; i < eip->vert_count; i++) {
(*b)->NewVertex(sketch_plane.PointAt(eip->verts[i][0], eip->verts[i][1]), 0.0);
}
// Create the brep elements corresponding to the sketch lines, curves
// and bezier segments. Create 2d, 3d and BrepEdge elements for each segment.
// Will need to use the bboxes of each element to
// build the overall bounding box for the face. Use bGrowBox to expand
// a single box.
struct line_seg *lsg;
struct carc_seg *csg;
struct bezier_seg *bsg;
uint32_t *lng;
for (size_t i = 0; i < (&eip->curve)->count; i++) {
lng = (uint32_t *)(&eip->curve)->segment[i];
switch (*lng) {
case CURVE_LSEG_MAGIC: {
lsg = (struct line_seg *)lng;
ON_Curve* lsg3d = new ON_LineCurve((*b)->m_V[lsg->start].Point(), (*b)->m_V[lsg->end].Point());
lsg3d->SetDomain(0.0, 1.0);
(*b)->m_C3.Append(lsg3d);
}
break;
case CURVE_CARC_MAGIC:
csg = (struct carc_seg *)lng;
if (csg->radius < 0) { {
ON_3dPoint cntrpt = (*b)->m_V[csg->end].Point();
ON_3dPoint edgept = (*b)->m_V[csg->start].Point();
ON_Plane cplane = ON_Plane(cntrpt, plane_x_dir, plane_y_dir);
ON_Circle c3dcirc = ON_Circle(cplane, cntrpt.DistanceTo(edgept));
ON_Curve* c3d = new ON_ArcCurve((const ON_Circle)c3dcirc);
c3d->SetDomain(0.0, 1.0);
(*b)->m_C3.Append(c3d);
}
} else {
// need to calculated 3rd point on arc - look to sketch.c around line 581 for
// logic
}
break;
case CURVE_BEZIER_MAGIC:
bsg = (struct bezier_seg *)lng;
{
ON_3dPointArray bezpoints = ON_3dPointArray(bsg->degree + 1);
for (int j = 0; j < bsg->degree + 1; j++) {
bezpoints.Append((*b)->m_V[bsg->ctl_points[j]].Point());
}
ON_BezierCurve bez3d = ON_BezierCurve((const ON_3dPointArray)bezpoints);
ON_NurbsCurve* beznurb3d = ON_NurbsCurve::New();
bez3d.GetNurbForm(*beznurb3d);
beznurb3d->SetDomain(0.0, 1.0);
(*b)->m_C3.Append(beznurb3d);
}
break;
default:
bu_log("Unhandled sketch object\n");
break;
}
}
vect_t endpoint;
VADD2(endpoint, rip->v3d, rip->axis3d);
const ON_Line& revaxis = ON_Line(ON_3dPoint(rip->v3d), ON_3dPoint(endpoint));
FindLoops(b, &revaxis, rip->ang);
// Create the two boundary surfaces, if it's not a full revolution
if (!full_revolve) {
// First, deduce the transformation matrices to calculate the position of the end surface
// The transformation matrices are to rotate an arbitrary point around an arbitrary axis
// Let the point A = (x, y, z), the rotation axis is p1p2 = (x2,y2,z2)-(x1,y1,z1) = (a,b,c)
// Then T1 is to translate p1 to the origin
// Rx is to rotate p1p2 around the X axis to the plane XOZ
// Ry is to rotate p1p2 around the Y axis to be coincident to Z axis
// Rz is to rotate A with the angle around Z axis (the new p1p2)
// RxInv, RyInv, T1Inv are the inverse transformation of Rx, Ry, T1, respectively.
// The whole transformation is A' = A*T1*Rx*Ry*Rz*Ry*Inv*Rx*Inv = A*R
vect_t end_plane_origin, end_plane_x_dir, end_plane_y_dir;
mat_t R;
MAT_IDN(R);
mat_t T1, Rx, Ry, Rz, RxInv, RyInv, T1Inv;
MAT_IDN(T1);
VSET(&T1[12], -rip->v3d[0], -rip->v3d[1], -rip->v3d[2]);
MAT_IDN(Rx);
fastf_t v = sqrt(rip->axis3d[1]*rip->axis3d[1]+rip->axis3d[2]*rip->axis3d[2]);
VSET(&Rx[4], 0, rip->axis3d[2]/v, rip->axis3d[1]/v);
VSET(&Rx[8], 0, -rip->axis3d[1]/v, rip->axis3d[2]/v);
MAT_IDN(Ry);
fastf_t u = MAGNITUDE(rip->axis3d);
VSET(&Ry[0], v/u, 0, -rip->axis3d[0]/u);
VSET(&Ry[8], rip->axis3d[0]/u, 0, v/u);
MAT_IDN(Rz);
fastf_t C, S;
C = cos(rip->ang);
S = sin(rip->ang);
VSET(&Rz[0], C, S, 0);
VSET(&Rz[4], -S, C, 0);
bn_mat_inv(RxInv, Rx);
bn_mat_inv(RyInv, Ry);
bn_mat_inv(T1Inv, T1);
mat_t temp;
bn_mat_mul4(temp, T1, Rx, Ry, Rz);
bn_mat_mul4(R, temp, RyInv, RxInv, T1Inv);
VEC3X3MAT(end_plane_origin, plane_origin, R);
VADD2(end_plane_origin, end_plane_origin, &R[12]);
VEC3X3MAT(end_plane_x_dir, plane_x_dir, R);
VEC3X3MAT(end_plane_y_dir, plane_y_dir, R);
// Create the start and end surface with rt_sketch_brep()
struct rt_sketch_internal sketch;
sketch = *(rip->skt);
ON_Brep *b1 = ON_Brep::New();
VMOVE(sketch.V, plane_origin);
VMOVE(sketch.u_vec, plane_x_dir);
VMOVE(sketch.v_vec, plane_y_dir);
tmp_internal->idb_ptr = (void *)(&sketch);
rt_sketch_brep(&b1, tmp_internal, tol);
(*b)->Append(*b1->Duplicate());
ON_Brep *b2 = ON_Brep::New();
VMOVE(sketch.V, end_plane_origin);
VMOVE(sketch.u_vec, end_plane_x_dir);
VMOVE(sketch.v_vec, end_plane_y_dir);
tmp_internal->idb_ptr = (void *)(&sketch);
rt_sketch_brep(&b2, tmp_internal, tol);
(*b)->Append(*b2->Duplicate());
(*b)->FlipFace((*b)->m_F[(*b)->m_F.Count()-1]);
}
bu_free(tmp_internal, "free temporary rt_db_internal");
}
int
ged_shells(struct ged *gedp, int argc, const char *argv[])
{
struct directory *old_dp, *new_dp;
struct rt_db_internal old_intern, new_intern;
struct model *m_tmp, *m;
struct nmgregion *r_tmp, *r;
struct shell *s_tmp, *s;
int shell_count=0;
struct bu_vls shell_name = BU_VLS_INIT_ZERO;
long **trans_tbl;
static const char *usage = "nmg_model";
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 != 2) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
if ((old_dp = db_lookup(gedp->ged_wdbp->dbip, argv[1], LOOKUP_NOISY)) == RT_DIR_NULL)
return GED_ERROR;
if (rt_db_get_internal(&old_intern, old_dp, gedp->ged_wdbp->dbip, bn_mat_identity, &rt_uniresource) < 0) {
bu_vls_printf(gedp->ged_result_str, "rt_db_get_internal() error\n");
return GED_ERROR;
}
if (old_intern.idb_type != ID_NMG) {
bu_vls_printf(gedp->ged_result_str, "Object is not an NMG!!!\n");
return GED_ERROR;
}
m = (struct model *)old_intern.idb_ptr;
NMG_CK_MODEL(m);
for (BU_LIST_FOR(r, nmgregion, &m->r_hd)) {
for (BU_LIST_FOR(s, shell, &r->s_hd)) {
s_tmp = nmg_dup_shell(s, &trans_tbl, &gedp->ged_wdbp->wdb_tol);
bu_free((void *)trans_tbl, "trans_tbl");
m_tmp = nmg_mmr();
r_tmp = BU_LIST_FIRST(nmgregion, &m_tmp->r_hd);
BU_LIST_DEQUEUE(&s_tmp->l);
BU_LIST_APPEND(&r_tmp->s_hd, &s_tmp->l);
s_tmp->r_p = r_tmp;
nmg_m_reindex(m_tmp, 0);
nmg_m_reindex(m, 0);
bu_vls_printf(&shell_name, "shell.%d", shell_count);
while (db_lookup(gedp->ged_wdbp->dbip, bu_vls_addr(&shell_name), 0) != RT_DIR_NULL) {
bu_vls_trunc(&shell_name, 0);
shell_count++;
bu_vls_printf(&shell_name, "shell.%d", shell_count);
}
/* Export NMG as a new solid */
RT_DB_INTERNAL_INIT(&new_intern);
new_intern.idb_major_type = DB5_MAJORTYPE_BRLCAD;
new_intern.idb_type = ID_NMG;
new_intern.idb_meth = &OBJ[ID_NMG];
new_intern.idb_ptr = (void *)m_tmp;
new_dp=db_diradd(gedp->ged_wdbp->dbip, bu_vls_addr(&shell_name), RT_DIR_PHONY_ADDR, 0, RT_DIR_SOLID, (void *)&new_intern.idb_type);
if (new_dp == RT_DIR_NULL) {
bu_vls_printf(gedp->ged_result_str, "An error has occurred while adding a new object to the database.\n");
return GED_ERROR;
}
/* make sure the geometry/bounding boxes are up to date */
nmg_rebound(m_tmp, &gedp->ged_wdbp->wdb_tol);
if (rt_db_put_internal(new_dp, gedp->ged_wdbp->dbip, &new_intern, &rt_uniresource) < 0) {
/* Free memory */
nmg_km(m_tmp);
bu_vls_printf(gedp->ged_result_str, "rt_db_put_internal() failure\n");
return GED_ERROR;
}
/* Internal representation has been freed by rt_db_put_internal */
new_intern.idb_ptr = (void *)NULL;
}
}
bu_vls_free(&shell_name);
return GED_OK;
}
int
rt_comb_import4(
struct rt_db_internal *ip,
const struct bu_external *ep,
const mat_t matrix, /* NULL if identity */
const struct db_i *dbip,
struct resource *resp)
{
union record *rp;
struct rt_tree_array *rt_tree_array;
union tree *tree;
struct rt_comb_internal *comb;
size_t j;
size_t node_count;
BU_CK_EXTERNAL(ep);
rp = (union record *)ep->ext_buf;
if (dbip) RT_CK_DBI(dbip);
if (rp[0].u_id != ID_COMB) {
bu_log("rt_comb_import4: Attempt to import a non-combination\n");
return -1;
}
/* Compute how many granules of MEMBER records follow */
node_count = ep->ext_nbytes/sizeof(union record) - 1;
if (node_count)
rt_tree_array = (struct rt_tree_array *)bu_calloc(node_count, sizeof(struct rt_tree_array), "rt_tree_array");
else
rt_tree_array = (struct rt_tree_array *)NULL;
for (j = 0; j < node_count; j++) {
if (rp[j+1].u_id != ID_MEMB) {
bu_free((void *)rt_tree_array, "rt_comb_import4: rt_tree_array");
bu_log("rt_comb_import4(): granule in external buffer is not ID_MEMB, id=%d\n", rp[j+1].u_id);
return -1;
}
switch (rp[j+1].M.m_relation) {
case '+':
rt_tree_array[j].tl_op = OP_INTERSECT;
break;
case '-':
rt_tree_array[j].tl_op = OP_SUBTRACT;
break;
default:
bu_log("rt_comb_import4() unknown op=x%x, assuming UNION\n", rp[j+1].M.m_relation);
/* Fall through */
case 'u':
rt_tree_array[j].tl_op = OP_UNION;
break;
}
/* Build leaf node for in-memory tree */
{
union tree *tp;
mat_t diskmat;
char namebuf[NAMESIZE+1];
RT_GET_TREE(tp, resp);
rt_tree_array[j].tl_tree = tp;
tp->tr_l.tl_op = OP_DB_LEAF;
/* bu_strlcpy not safe here, buffer size mismatch */
memset(namebuf, 0, NAMESIZE+1);
memcpy(namebuf, rp[j+1].M.m_instname, sizeof(rp[j+1].M.m_instname));
tp->tr_l.tl_name = bu_strdup(namebuf);
flip_mat_dbmat(diskmat, rp[j+1].M.m_mat, dbip->dbi_version < 0 ? 1 : 0);
/* Verify that rotation part is pure rotation */
if (fabs(diskmat[0]) > 1 || fabs(diskmat[1]) > 1 ||
fabs(diskmat[2]) > 1 ||
fabs(diskmat[4]) > 1 || fabs(diskmat[5]) > 1 ||
fabs(diskmat[6]) > 1 ||
fabs(diskmat[8]) > 1 || fabs(diskmat[9]) > 1 ||
fabs(diskmat[10]) > 1)
{
bu_log("ERROR: %s/%s improper scaling, rotation matrix elements > 1\n",
rp[0].c.c_name, namebuf);
}
/* Verify that perspective isn't used as a modeling transform */
if (!ZERO(diskmat[12])
|| !ZERO(diskmat[13])
|| !ZERO(diskmat[14]))
{
bu_log("ERROR: %s/%s has perspective transform\n", rp[0].c.c_name, namebuf);
}
/* See if disk record is identity matrix */
if (bn_mat_is_identity(diskmat)) {
if (matrix == NULL) {
tp->tr_l.tl_mat = NULL; /* identity */
} else {
tp->tr_l.tl_mat = bn_mat_dup(matrix);
}
} else {
if (matrix == NULL) {
tp->tr_l.tl_mat = bn_mat_dup(diskmat);
} else {
mat_t prod;
bn_mat_mul(prod, matrix, diskmat);
tp->tr_l.tl_mat = bn_mat_dup(prod);
}
}
/* bu_log("M_name=%s, matp=x%x\n", tp->tr_l.tl_name, tp->tr_l.tl_mat); */
}
}
if (node_count)
tree = db_mkgift_tree(rt_tree_array, node_count, &rt_uniresource);
else
tree = (union tree *)NULL;
RT_DB_INTERNAL_INIT(ip);
ip->idb_major_type = DB5_MAJORTYPE_BRLCAD;
ip->idb_type = ID_COMBINATION;
ip->idb_meth = &OBJ[ID_COMBINATION];
BU_ALLOC(comb, struct rt_comb_internal);
RT_COMB_INTERNAL_INIT(comb);
comb->tree = tree;
ip->idb_ptr = (void *)comb;
switch (rp[0].c.c_flags) {
case DBV4_NON_REGION_NULL:
case DBV4_NON_REGION:
comb->region_flag = 0;
break;
case DBV4_REGION:
comb->region_flag = 1;
comb->is_fastgen = REGION_NON_FASTGEN;
break;
case DBV4_REGION_FASTGEN_PLATE:
comb->region_flag = 1;
comb->is_fastgen = REGION_FASTGEN_PLATE;
break;
case DBV4_REGION_FASTGEN_VOLUME:
comb->region_flag = 1;
comb->is_fastgen = REGION_FASTGEN_VOLUME;
break;
default:
bu_log("WARNING: combination %s has illegal c_flag=x%x\n",
rp[0].c.c_name, rp[0].c.c_flags);
break;
}
if (comb->region_flag) {
if (dbip->dbi_version < 0) {
comb->region_id = flip_short(rp[0].c.c_regionid);
comb->aircode = flip_short(rp[0].c.c_aircode);
comb->GIFTmater = flip_short(rp[0].c.c_material);
comb->los = flip_short(rp[0].c.c_los);
} else {
comb->region_id = rp[0].c.c_regionid;
comb->aircode = rp[0].c.c_aircode;
comb->GIFTmater = rp[0].c.c_material;
comb->los = rp[0].c.c_los;
}
} else {
/* set some reasonable defaults */
comb->region_id = 0;
comb->aircode = 0;
comb->GIFTmater = 0;
comb->los = 0;
}
comb->rgb_valid = rp[0].c.c_override;
if (comb->rgb_valid) {
comb->rgb[0] = rp[0].c.c_rgb[0];
comb->rgb[1] = rp[0].c.c_rgb[1];
comb->rgb[2] = rp[0].c.c_rgb[2];
}
if (rp[0].c.c_matname[0] != '\0') {
#define MAX_SS 128
char shader_str[MAX_SS];
memset(shader_str, 0, MAX_SS);
/* copy shader info to a static string */
/* write shader name. c_matname is a buffer, bu_strlcpy not
* safe here.
*/
memcpy(shader_str, rp[0].c.c_matname, sizeof(rp[0].c.c_matname));
bu_strlcat(shader_str, " ", MAX_SS);
/* write shader parameters. c_matparm is a buffer, bu_strlcpy
* not safe here.
*/
memcpy(shader_str+strlen(shader_str), rp[0].c.c_matparm, sizeof(rp[0].c.c_matparm));
/* convert to TCL format and place into comb->shader */
if (bu_shader_to_list(shader_str, &comb->shader)) {
bu_log("rt_comb_import4: Error: Cannot convert following shader to TCL format:\n");
bu_log("\t%s\n", shader_str);
bu_vls_free(&comb->shader);
return -1;
}
}
/* XXX Separate flags for color inherit, shader inherit, (new) material inherit? */
/* XXX cf: ma_cinherit, ma_minherit */
/* This ? is necessary to clean up old databases with grunge here */
comb->inherit = (rp[0].c.c_inherit == DB_INH_HIGHER) ? 1 : 0;
/* Automatic material table lookup here? */
if (comb->region_flag)
bu_vls_printf(&comb->material, "gift%ld", comb->GIFTmater);
if (rt_tree_array) bu_free((void *)rt_tree_array, "rt_tree_array");
return 0;
}
/**
* Apply a 4x4 transformation matrix to the internal form of a solid.
*
* If "free" flag is non-zero, storage for the original solid is
* released. If "os" is same as "is", storage for the original solid
* is overwritten with the new, transformed solid.
*
* Returns -
* -1 FAIL
* 0 OK
*/
int
rt_generic_xform(
struct rt_db_internal *op,
const mat_t mat,
struct rt_db_internal *ip,
int release,
struct db_i *dbip,
struct resource *resp)
{
struct bu_external ext;
int id;
struct bu_attribute_value_set avs;
RT_CK_DB_INTERNAL(ip);
RT_CK_DBI(dbip);
RT_CK_RESOURCE(resp);
memset(&avs, 0, sizeof(struct bu_attribute_value_set));
id = ip->idb_type;
BU_EXTERNAL_INIT(&ext);
/* Scale change on export is 1.0 -- no change */
switch (db_version(dbip)) {
case 4:
if (OBJ[id].ft_export4(&ext, ip, 1.0, dbip, resp) < 0) {
bu_log("rt_generic_xform(): %s export failure\n",
OBJ[id].ft_name);
return -1; /* FAIL */
}
if ((release || op == ip)) rt_db_free_internal(ip);
RT_DB_INTERNAL_INIT(op);
if (OBJ[id].ft_import4(op, &ext, mat, dbip, resp) < 0) {
bu_log("rt_generic_xform(): solid import failure\n");
return -1; /* FAIL */
}
break;
case 5:
if (OBJ[id].ft_export5(&ext, ip, 1.0, dbip, resp) < 0) {
bu_log("rt_generic_xform(): %s export failure\n",
OBJ[id].ft_name);
return -1; /* FAIL */
}
if ((release || op == ip)) {
if (ip->idb_avs.magic == BU_AVS_MAGIC) {
/* grab the attributes before they are lost
* by rt_db_free_internal or RT_DB_INTERNAL_INIT
*/
bu_avs_init(&avs, ip->idb_avs.count, "avs");
bu_avs_merge(&avs, &ip->idb_avs);
}
rt_db_free_internal(ip);
}
RT_DB_INTERNAL_INIT(op);
if (!release && op != ip) {
/* just copy the attributes from ip to op */
if (ip->idb_avs.magic == BU_AVS_MAGIC) {
bu_avs_init(&op->idb_avs, ip->idb_avs.count, "avs");
bu_avs_merge(&op->idb_avs, &ip->idb_avs);
}
} else if (avs.magic == BU_AVS_MAGIC) {
/* put the saved attributes in the output */
bu_avs_init(&op->idb_avs, avs.count, "avs");
bu_avs_merge(&op->idb_avs, &avs);
bu_avs_free(&avs);
}
if (OBJ[id].ft_import5(op, &ext, mat, dbip, resp) < 0) {
bu_log("rt_generic_xform(): solid import failure\n");
return -1; /* FAIL */
}
break;
}
bu_free_external(&ext);
RT_CK_DB_INTERNAL(op);
return 0; /* OK */
}
/*
* This routine is called (at prep time)
* once for each region which uses this shader.
* Any shader-specific initialization should be done here.
*
* Returns:
* 1 success
* 0 success, but delete region
* -1 failure
*/
HIDDEN int
bbd_setup(struct region *rp, struct bu_vls *matparm, void **dpp, const struct mfuncs *mfp, struct rt_i *rtip)
{
register struct bbd_specific *bbd_sp;
struct rt_db_internal intern;
struct rt_tgc_internal *tgc;
int s;
mat_t mat;
struct bbd_img *bi;
double angle;
vect_t vtmp;
int img_num;
vect_t vv;
/* check the arguments */
RT_CHECK_RTI(rtip);
BU_CK_VLS(matparm);
RT_CK_REGION(rp);
if (rdebug&RDEBUG_SHADE) bu_log("bbd_setup(%s)\n", rp->reg_name);
RT_CK_TREE(rp->reg_treetop);
if (rp->reg_treetop->tr_a.tu_op != OP_SOLID) {
bu_log("--- Warning: Region %s shader %s", rp->reg_name, mfp->mf_name);
bu_bomb("Shader should be used on region of single (rec/rcc) primitive\n");
}
RT_CK_SOLTAB(rp->reg_treetop->tr_a.tu_stp);
if (rp->reg_treetop->tr_a.tu_stp->st_id != ID_REC) {
bu_log("--- Warning: Region %s shader %s", rp->reg_name, mfp->mf_name);
bu_log("Shader should be used on region of single REC/RCC primitive %d\n",
rp->reg_treetop->tr_a.tu_stp->st_id);
bu_bomb("oops\n");
}
/* Get memory for the shader parameters and shader-specific data */
BU_GET(bbd_sp, struct bbd_specific);
*dpp = bbd_sp;
/* initialize the default values for the shader */
memcpy(bbd_sp, &bbd_defaults, sizeof(struct bbd_specific));
bu_vls_init(&bbd_sp->img_filename);
BU_LIST_INIT(&bbd_sp->imgs);
bbd_sp->rtip = rtip; /* because new_image() needs this */
bbd_sp->img_count = 0;
/* parse the user's arguments for this use of the shader. */
if (bu_struct_parse(matparm, bbd_parse_tab, (char *)bbd_sp, NULL) < 0)
return -1;
if (bbd_sp->img_count > MAX_IMAGES) {
bu_log("too many images (%zu) in shader for %s sb < %d\n",
bbd_sp->img_count, rp->reg_name, MAX_IMAGES);
bu_bomb("excessive image count\n");
}
MAT_IDN(mat);
RT_DB_INTERNAL_INIT(&intern);
s = rt_db_get_internal(&intern, rp->reg_treetop->tr_a.tu_stp->st_dp, rtip->rti_dbip,
mat, &rt_uniresource);
if (intern.idb_minor_type != ID_TGC &&
intern.idb_minor_type != ID_REC) {
bu_log("What did I get? %d\n", intern.idb_minor_type);
}
if (s < 0) {
bu_log("%s:%d didn't get internal", __FILE__, __LINE__);
bu_bomb("");
}
tgc = (struct rt_tgc_internal *)intern.idb_ptr;
RT_TGC_CK_MAGIC(tgc);
angle = M_PI / (double)bbd_sp->img_count;
img_num = 0;
VMOVE(vv, tgc->h);
VUNITIZE(vv);
for (BU_LIST_FOR(bi, bbd_img, &bbd_sp->imgs)) {
static const point_t o = VINIT_ZERO;
bn_mat_arb_rot(mat, o, vv, angle*img_num);
/* compute plane equation */
MAT4X3VEC(bi->img_plane, mat, tgc->a);
VUNITIZE(bi->img_plane);
bi->img_plane[H] = VDOT(tgc->v, bi->img_plane);
MAT4X3VEC(vtmp, mat, tgc->b);
VADD2(bi->img_origin, tgc->v, vtmp); /* image origin in 3d space */
/* calculate image u vector */
VREVERSE(bi->img_x, vtmp);
VUNITIZE(bi->img_x);
bi->img_xlen = MAGNITUDE(vtmp) * 2;
/* calculate image v vector */
VMOVE(bi->img_y, tgc->h);
VUNITIZE(bi->img_y);
bi->img_ylen = MAGNITUDE(tgc->h);
if (rdebug&RDEBUG_SHADE) {
HPRINT("\nimg_plane", bi->img_plane);
VPRINT("vtmp", vtmp);
VPRINT("img_origin", bi->img_origin);
bu_log("img_xlen:%g ", bi->img_xlen);
VPRINT("img_x", bi->img_x);
bu_log("img_ylen:%g ", bi->img_ylen);
VPRINT("img_y", bi->img_y);
}
img_num++;
}
rt_db_free_internal(&intern);
if (rdebug&RDEBUG_SHADE) {
bu_struct_print(" Parameters:", bbd_print_tab, (char *)bbd_sp);
}
return 1;
}
static int
plot_shaded_eval(
struct ged *gedp,
const char *path_name,
struct _ged_client_data *dgcdp)
{
int ret;
const char *av[3];
const char *tmp_basename = "tmp_shaded_eval_obj";
char *brep_name;
/* make a name for the temp brep */
av[0] = "make_name";
av[1] = tmp_basename;
ged_make_name(gedp, 2, (const char **)av);
brep_name = bu_vls_strdup(gedp->ged_result_str);
bu_vls_trunc(gedp->ged_result_str, 0);
/* create temp evaluated brep from named object */
av[0] = "brep";
av[1] = path_name;
av[2] = brep_name;
ret = ged_brep(gedp, 3, av);
if (ret == GED_OK) {
int brep_made = 0;
struct db_tree_state ts;
struct rt_db_internal brep_intern;
struct db_full_path input_path, brep_path;
RT_DB_INTERNAL_INIT(&brep_intern);
db_full_path_init(&input_path);
db_full_path_init(&brep_path);
/* get brep internal */
ret = get_path_and_state(&ts, &brep_path, brep_name, gedp);
if (ret == GED_OK) {
struct directory *dp = DB_FULL_PATH_CUR_DIR(&brep_path);
if (dp->d_flags & RT_DIR_COMB) {
ret = rt_db_get_internal(&brep_intern, dp, ts.ts_dbip, NULL,
ts.ts_resp);
} else {
ret = rt_db_get_internal(&brep_intern, dp, ts.ts_dbip, ts.ts_mat,
ts.ts_resp);
}
if (ret >= 0) {
brep_made = 1;
}
db_free_full_path(&brep_path);
}
/* plot brep, but use the path and state of the input object */
if (brep_made) {
ret = get_path_and_state(&ts, &input_path, path_name, gedp);
if (ret == GED_OK) {
plot_shaded(&ts, &input_path, &brep_intern, dgcdp);
rt_db_free_internal(&brep_intern);
db_free_full_path(&input_path);
}
}
/* kill temp brep */
av[0] = "kill";
av[1] = brep_name;
ged_kill(gedp, 2, av);
}
bu_free((char *)brep_name, "vls_strdup");
return ret;
}
int
ged_bot_fuse(struct ged *gedp, int argc, const char **argv)
{
struct directory *old_dp, *new_dp;
struct rt_db_internal intern, intern2;
struct rt_bot_internal *bot;
int count=0;
static const char *usage = "new_bot old_bot";
struct model *m;
struct nmgregion *r;
int ret, c, i;
struct bn_tol *tol = &gedp->ged_wdbp->wdb_tol;
int total = 0;
volatile int out_type = 0; /* open edge output type: 0 = none, 1 = show, 2 = plot */
size_t open_cnt;
struct bu_vls name_prefix = BU_VLS_INIT_ZERO;
/* bu_getopt() options */
static const char *bot_fuse_options = "sp";
static const char *bot_fuse_options_str = "[-s|-p]";
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 != 3 && argc != 4) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s %s", argv[0], bot_fuse_options_str, usage);
return GED_HELP;
}
/* Turn off getopt's error messages */
bu_opterr = 0;
bu_optind = 1;
/* get all the option flags from the command line */
while ((c=bu_getopt(argc, (char **)argv, bot_fuse_options)) != -1) {
switch (c) {
case 's':
{
out_type = 1; /* show open edges */
break;
}
case 'p':
{
out_type = 2; /* plot open edges */
break;
}
default :
{
bu_vls_printf(gedp->ged_result_str, "Unknown option: '%c'", c);
return GED_HELP;
}
}
}
i = argc - 2;
bu_log("%s: start\n", argv[0]);
GED_DB_LOOKUP(gedp, old_dp, argv[i+1], LOOKUP_NOISY, GED_ERROR & GED_QUIET);
GED_DB_GET_INTERNAL(gedp, &intern, old_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], argv[i+1]);
return GED_ERROR;
}
/* create nmg model structure */
m = nmg_mm();
/* place bot in nmg structure */
bu_log("%s: running rt_bot_tess\n", argv[0]);
ret = rt_bot_tess(&r, m, &intern, &gedp->ged_wdbp->wdb_ttol, tol);
/* free internal representation of original bot */
rt_db_free_internal(&intern);
if (ret != 0) {
bu_vls_printf(gedp->ged_result_str, "%s: %s fuse failed (1).\n", argv[0], argv[i+1]);
nmg_km(m);
return GED_ERROR;
}
total = 0;
/* Step 1 -- the vertices. */
bu_log("%s: running nmg_vertex_fuse\n", argv[0]);
count = nmg_vertex_fuse(&m->magic, tol);
total += count;
bu_log("%s: %s, %d vertex fused\n", argv[0], argv[i+1], count);
/* Step 1.5 -- break edges on vertices, before fusing edges */
bu_log("%s: running nmg_break_e_on_v\n", argv[0]);
count = nmg_break_e_on_v(&m->magic, tol);
total += count;
bu_log("%s: %s, %d broke 'e' on 'v'\n", argv[0], argv[i+1], count);
if (total) {
struct nmgregion *r2;
struct shell *s;
bu_log("%s: running nmg_make_faces_within_tol\n", argv[0]);
/* vertices and/or edges have been moved,
* may have created out-of-tolerance faces
*/
for (BU_LIST_FOR(r2, nmgregion, &m->r_hd)) {
for (BU_LIST_FOR(s, shell, &r2->s_hd))
nmg_make_faces_within_tol(s, tol);
}
}
/* Step 2 -- the face geometry */
bu_log("%s: running nmg_model_face_fuse\n", argv[0]);
count = nmg_model_face_fuse(m, tol);
total += count;
bu_log("%s: %s, %d faces fused\n", argv[0], argv[i+1], count);
/* Step 3 -- edges */
bu_log("%s: running nmg_edge_fuse\n", argv[0]);
count = nmg_edge_fuse(&m->magic, tol);
total += count;
bu_log("%s: %s, %d edges fused\n", argv[0], argv[i+1], count);
bu_log("%s: %s, %d total fused\n", argv[0], argv[i+1], total);
if (!BU_SETJUMP) {
/* try */
/* convert the nmg model back into a bot */
bot = nmg_bot(BU_LIST_FIRST(shell, &r->s_hd), tol);
bu_vls_sprintf(&name_prefix, "open_edges.%s", argv[i]);
bu_log("%s: running show_dangling_edges\n", argv[0]);
open_cnt = show_dangling_edges(gedp, &m->magic, bu_vls_addr(&name_prefix), out_type);
bu_log("%s: WARNING %ld open edges, new BOT may be invalid!!!\n", argv[0], open_cnt);
bu_vls_free(&name_prefix);
/* free the nmg model structure */
nmg_km(m);
} else {
/* catch */
BU_UNSETJUMP;
bu_vls_printf(gedp->ged_result_str, "%s: %s fuse failed (2).\n", argv[0], argv[i+1]);
return GED_ERROR;
} BU_UNSETJUMP;
RT_DB_INTERNAL_INIT(&intern2);
intern2.idb_major_type = DB5_MAJORTYPE_BRLCAD;
intern2.idb_type = ID_BOT;
intern2.idb_meth = &OBJ[ID_BOT];
intern2.idb_ptr = (void *)bot;
GED_DB_DIRADD(gedp, new_dp, argv[i], RT_DIR_PHONY_ADDR, 0, RT_DIR_SOLID, (void *)&intern2.idb_type, GED_ERROR);
GED_DB_PUT_INTERNAL(gedp, new_dp, &intern2, &rt_uniresource, GED_ERROR);
bu_log("%s: Created new BOT (%s)\n", argv[0], argv[i]);
bu_log("%s: Done.\n", argv[0]);
return GED_OK;
}
/*
* This is a helper routine used in txt_setup() to load a texture either from
* a file or from a db object. The resources are released in txt_free()
* (there is no specific unload_datasource function).
*/
HIDDEN int
txt_load_datasource(struct txt_specific *texture, struct db_i *dbInstance, const unsigned long int size)
{
struct directory *dirEntry;
RT_CK_DBI(dbInstance);
if (texture == (struct txt_specific *)NULL) {
bu_bomb("ERROR: txt_load_datasource() received NULL arg (struct txt_specific *)\n");
}
bu_log("Loading texture %s [%s]...", texture->tx_datasrc==TXT_SRC_AUTO?"from auto-determined datasource":texture->tx_datasrc==TXT_SRC_OBJECT?"from a database object":texture->tx_datasrc==TXT_SRC_FILE?"from a file":"from an unknown source (ERROR)", bu_vls_addr(&texture->tx_name));
/* if the source is auto or object, we try to load the object */
if ((texture->tx_datasrc==TXT_SRC_AUTO) || (texture->tx_datasrc==TXT_SRC_OBJECT)) {
/* see if the object exists */
if ((dirEntry=db_lookup(dbInstance, bu_vls_addr(&texture->tx_name), LOOKUP_QUIET)) == RT_DIR_NULL) {
/* unable to find the texture object */
if (texture->tx_datasrc!=TXT_SRC_AUTO) {
return -1;
}
} else {
struct rt_db_internal *dbip;
BU_ALLOC(dbip, struct rt_db_internal);
RT_DB_INTERNAL_INIT(dbip);
RT_CK_DB_INTERNAL(dbip);
RT_CK_DIR(dirEntry);
/* the object was in the directory, so go get it */
if (rt_db_get_internal(dbip, dirEntry, dbInstance, NULL, NULL) <= 0) {
/* unable to load/create the texture database record object */
return -1;
}
RT_CK_DB_INTERNAL(dbip);
RT_CK_BINUNIF(dbip->idb_ptr);
/* keep the binary object pointer */
texture->tx_binunifp=(struct rt_binunif_internal *)dbip->idb_ptr; /* make it so */
/* release the database instance pointer struct we created */
RT_DB_INTERNAL_INIT(dbip);
bu_free(dbip, "txt_load_datasource");
/* check size of object */
if (texture->tx_binunifp->count < size) {
bu_log("\nWARNING: %s needs %d bytes, binary object only has %lu\n", bu_vls_addr(&texture->tx_name), size, texture->tx_binunifp->count);
} else if (texture->tx_binunifp->count > size) {
bu_log("\nWARNING: Binary object is larger than specified texture size\n\tBinary Object: %zu pixels\n\tSpecified Texture Size: %zu pixels\n...continuing to load using image subsection...", texture->tx_binunifp->count);
}
}
}
/* if we are auto and we couldn't find a database object match, or if source
* is explicitly a file then we load the file.
*/
if (((texture->tx_datasrc==TXT_SRC_AUTO) && (texture->tx_binunifp==NULL)) || (texture->tx_datasrc==TXT_SRC_FILE)) {
texture->tx_mp = bu_open_mapped_file_with_path(dbInstance->dbi_filepath, bu_vls_addr(&texture->tx_name), NULL);
if (texture->tx_mp==NULL)
return -1; /* FAIL */
if (texture->tx_mp->buflen < size) {
bu_log("\nWARNING: %s needs %d bytes, file only has %lu\n", bu_vls_addr(&texture->tx_name), size, texture->tx_mp->buflen);
} else if (texture->tx_mp->buflen > size) {
bu_log("\nWARNING: Texture file size is larger than specified texture size\n\tInput File: %zu pixels\n\tSpecified Texture Size: %lu pixels\n...continuing to load using image subsection...", texture->tx_mp->buflen, size);
}
}
bu_log("done.\n");
return 0;
}
int
ged_comb_std(struct ged *gedp, int argc, const char *argv[])
{
char *comb_name;
int ch;
int region_flag = -1;
struct directory *dp = RT_DIR_NULL;
struct rt_db_internal intern;
struct rt_comb_internal *comb = NULL;
struct tokens tok_hd;
short last_tok;
int i;
union tree *final_tree;
static const char *usage = "[-cr] comb_name <boolean_expr>";
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 < 3) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
/* Parse options */
bu_optind = 1; /* re-init bu_getopt() */
while ((ch = bu_getopt(argc, (char * const *)argv, "cgr?")) != -1) {
switch (ch) {
case 'c':
case 'g':
region_flag = 0;
break;
case 'r':
region_flag = 1;
break;
/* XXX How about -p and -v for FASTGEN? */
case '?':
default:
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_OK;
}
}
argc -= (bu_optind + 1);
argv += bu_optind;
comb_name = (char *)*argv++;
if (argc == -1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_OK;
}
if ((region_flag != -1) && (argc == 0)) {
/*
* Set/Reset the REGION flag of an existing combination
*/
GED_DB_LOOKUP(gedp, dp, comb_name, LOOKUP_NOISY, GED_ERROR & GED_QUIET);
if (!(dp->d_flags & RT_DIR_COMB)) {
bu_vls_printf(gedp->ged_result_str, "%s is not a combination\n", comb_name);
return GED_ERROR;
}
GED_DB_GET_INTERNAL(gedp, &intern, dp, (fastf_t *)NULL, &rt_uniresource, GED_ERROR);
comb = (struct rt_comb_internal *)intern.idb_ptr;
RT_CK_COMB(comb);
if (region_flag) {
if (!comb->region_flag) {
/* assign values from the defaults */
comb->region_id = gedp->ged_wdbp->wdb_item_default++;
comb->aircode = gedp->ged_wdbp->wdb_air_default;
comb->GIFTmater = gedp->ged_wdbp->wdb_mat_default;
comb->los = gedp->ged_wdbp->wdb_los_default;
}
comb->region_flag = 1;
} else
comb->region_flag = 0;
GED_DB_PUT_INTERNAL(gedp, dp, &intern, &rt_uniresource, GED_ERROR);
return GED_OK;
}
/*
* At this point, we know we have a Boolean expression.
* If the combination already existed and region_flag is -1,
* then leave its region_flag alone.
* If the combination didn't exist yet,
* then pretend region_flag was 0.
* Otherwise, make sure to set its c_flags according to region_flag.
*/
GED_CHECK_EXISTS(gedp, comb_name, LOOKUP_QUIET, GED_ERROR);
dp = RT_DIR_NULL;
/* parse Boolean expression */
BU_LIST_INIT(&tok_hd.l);
tok_hd.type = TOK_NULL;
last_tok = TOK_LPAREN;
for (i = 0; i < argc; i++) {
char *ptr;
ptr = (char *)argv[i];
while (*ptr) {
while (*ptr == '(' || *ptr == ')') {
switch (*ptr) {
case '(':
append_lparen(&tok_hd.l);
last_tok = TOK_LPAREN;
break;
case ')':
append_rparen(&tok_hd.l);
last_tok = TOK_RPAREN;
break;
}
ptr++;
}
if (*ptr == '\0')
continue;
if (last_tok == TOK_RPAREN) {
/* next token MUST be an operator */
if (add_operator(gedp, &tok_hd.l, *ptr, &last_tok) == GED_ERROR) {
free_tokens(&tok_hd.l);
return GED_ERROR;
}
ptr++;
} else if (last_tok == TOK_LPAREN) {
/* next token MUST be an operand */
int name_len;
name_len = add_operand(gedp, &tok_hd.l, ptr);
if (name_len < 1) {
free_tokens(&tok_hd.l);
return GED_ERROR;
}
last_tok = TOK_TREE;
ptr += name_len;
} else if (last_tok == TOK_TREE) {
/* must be an operator */
if (add_operator(gedp, &tok_hd.l, *ptr, &last_tok) == GED_ERROR) {
free_tokens(&tok_hd.l);
return GED_ERROR;
}
ptr++;
} else if (last_tok == TOK_UNION ||
last_tok == TOK_INTER ||
last_tok == TOK_SUBTR) {
/* must be an operand */
int name_len;
name_len = add_operand(gedp, &tok_hd.l, ptr);
if (name_len < 1) {
free_tokens(&tok_hd.l);
return GED_ERROR;
}
last_tok = TOK_TREE;
ptr += name_len;
}
}
}
if (check_syntax(gedp, &tok_hd.l, comb_name, dp)) {
free_tokens(&tok_hd.l);
return GED_ERROR;
}
final_tree = eval_bool(&tok_hd.l);
{
int flags;
flags = RT_DIR_COMB;
BU_ALLOC(comb, struct rt_comb_internal);
RT_COMB_INTERNAL_INIT(comb);
comb->tree = final_tree;
comb->region_id = -1;
if (region_flag == (-1))
comb->region_flag = 0;
else
comb->region_flag = region_flag;
if (comb->region_flag) {
comb->region_flag = 1;
comb->region_id = gedp->ged_wdbp->wdb_item_default++;
comb->aircode = gedp->ged_wdbp->wdb_air_default;
comb->los = gedp->ged_wdbp->wdb_los_default;
comb->GIFTmater = gedp->ged_wdbp->wdb_mat_default;
bu_vls_printf(gedp->ged_result_str, "Creating region with attrs: region_id=%d, ", comb->region_id);
if (comb->aircode)
bu_vls_printf(gedp->ged_result_str, "air=%d, ", comb->aircode);
bu_vls_printf(gedp->ged_result_str, "los=%d, material_id=%d\n",
comb->los,
comb->GIFTmater);
flags |= RT_DIR_REGION;
}
RT_DB_INTERNAL_INIT(&intern);
intern.idb_major_type = DB5_MAJORTYPE_BRLCAD;
intern.idb_type = ID_COMBINATION;
intern.idb_meth = &OBJ[ID_COMBINATION];
intern.idb_ptr = (void *)comb;
GED_DB_DIRADD(gedp, dp, comb_name, RT_DIR_PHONY_ADDR, 0, flags, (void *)&intern.idb_type, GED_ERROR);
GED_DB_PUT_INTERNAL(gedp, dp, &intern, &rt_uniresource, GED_ERROR);
}
return GED_OK;
}
