void
diff_attrs_print(struct diff_result *dr, struct diff_state *state, struct bu_vls *diff_log) {
if (state->use_params == 1) {
struct diff_avp *minor_type = diff_ptbl_get(dr->param_diffs, "DB5_MINORTYPE");
if ((!minor_type || minor_type->state == DIFF_UNCHANGED || state->verbosity > 3) && BU_PTBL_LEN(dr->param_diffs) > 1) {
int i = 0;
for (i = 0; i < (int)BU_PTBL_LEN(dr->param_diffs); i++) {
struct diff_avp *avp = (struct diff_avp *)BU_PTBL_GET(dr->param_diffs, i);
if (state->return_added && avp->state == DIFF_ADDED) {
bu_vls_printf(diff_log, "A \"%s\" %s(p): %s\n", dr->obj_name, avp->name, avp->right_value);
}
if (state->return_removed && avp->state == DIFF_REMOVED) {
bu_vls_printf(diff_log, "D \"%s\" %s(p): %s\n", dr->obj_name, avp->name, avp->left_value);
}
if (state->return_changed && avp->state == DIFF_CHANGED) {
bu_vls_printf(diff_log, "- \"%s\" %s(p): %s\n+ \"%s\" %s(p): %s\n", dr->obj_name, avp->name, avp->left_value, dr->obj_name, avp->name, avp->right_value);
}
if (state->return_unchanged && avp->state == DIFF_UNCHANGED) {
bu_vls_printf(diff_log, " \"%s\" %s(p): %s\n", dr->obj_name, avp->name, avp->left_value);
}
}
} else {
if (minor_type)
bu_vls_printf(diff_log, "M \"%s\" %s->%s\n", dr->obj_name, minor_type->left_value, minor_type->right_value);
}
}
if (state->use_attrs == 1) {
int i = 0;
for (i = 0; i < (int)BU_PTBL_LEN(dr->attr_diffs); i++) {
struct diff_avp *avp = (struct diff_avp *)BU_PTBL_GET(dr->attr_diffs, i);
if (state->return_added && avp->state == DIFF_ADDED) {
bu_vls_printf(diff_log, "A \"%s\" %s(a): %s\n", dr->obj_name, avp->name, avp->right_value);
}
if (state->return_removed && avp->state == DIFF_REMOVED) {
bu_vls_printf(diff_log, "D \"%s\" %s(a): %s\n", dr->obj_name, avp->name, avp->left_value);
}
if (state->return_changed && avp->state == DIFF_CHANGED) {
bu_vls_printf(diff_log, "- \"%s\" %s(a): %s\n+ \"%s\" %s(a): %s\n", dr->obj_name, avp->name, avp->left_value, dr->obj_name, avp->name, avp->right_value);
}
if (state->return_unchanged && avp->state == DIFF_UNCHANGED) {
bu_vls_printf(diff_log, " \"%s\" %s(a): %s\n", dr->obj_name, avp->name, avp->left_value);
}
}
}
}
int
loadGeometry( char *fileName, struct bu_ptbl *objs) {
int sess_id = -1;
if ( BU_PTBL_LEN( objs ) > 0 ) {
char **objects;
int i;
objects = (char **)bu_malloc( BU_PTBL_LEN( objs ) * sizeof( char *), "objects" );
for ( i=0; i<(int)BU_PTBL_LEN( objs ); i++ ) {
objects[i] = (char *)BU_PTBL_GET( objs, i );
}
sess_id = rts_load_geometry(fileName, BU_PTBL_LEN( objs ), objects);
bu_free( objects, "objects");
} else {
fprintf( stderr, "No BRL-CAD model objects specified\n" );
bu_exit(1, usage, "rtserverTest");
}
return sess_id;
}
void
print_diff_summary(struct bu_ptbl *results)
{
int i = 0;
for (i = 0; i < (int)BU_PTBL_LEN(results); i++) {
struct diff_result *dr = (struct diff_result *)BU_PTBL_GET(results, i);
if (dr->param_state != DIFF_UNCHANGED) {
int j = 0;
bu_log("Object %s parameters have changed:\n", dr->obj_name);
for (j = 0; j < (int)BU_PTBL_LEN(dr->param_diffs); j++) {
struct diff_avp *avp = (struct diff_avp *)BU_PTBL_GET(dr->param_diffs, j);
if (avp->state == DIFF_ADDED)
bu_log("A %s: %s\n", avp->name, avp->right_value);
if (avp->state == DIFF_REMOVED)
bu_log("D %s: %s\n", avp->name, avp->left_value);
if (avp->state == DIFF_CHANGED)
bu_log("M %s: %s -> %s\n", avp->name, avp->left_value, avp->right_value);
}
bu_log("\n");
}
if (dr->attr_state != DIFF_UNCHANGED && dr->attr_state != DIFF_EMPTY) {
int j = 0;
bu_log("Object %s attributes have changed:\n", dr->obj_name);
for (j = 0; j < (int)BU_PTBL_LEN(dr->attr_diffs); j++) {
struct diff_avp *avp = (struct diff_avp *)BU_PTBL_GET(dr->attr_diffs, j);
if (avp->state == DIFF_ADDED)
bu_log("A %s: %s\n", avp->name, avp->right_value);
if (avp->state == DIFF_REMOVED)
bu_log("D %s: %s\n", avp->name, avp->left_value);
if (avp->state == DIFF_CHANGED)
bu_log("M %s: %s -> %s\n", avp->name, avp->left_value, avp->right_value);
}
bu_log("\n");
}
if ((dr->param_state != DIFF_UNCHANGED && dr->param_state != DIFF_EMPTY) ||
(dr->attr_state != DIFF_UNCHANGED && dr->attr_state != DIFF_EMPTY)) {
bu_log("\n");
}
}
}
void
diff_free_result(struct diff_result *result)
{
unsigned int i = 0;
if (result->obj_name) {
bu_free(result->obj_name, "free name copy in diff result");
}
BU_PUT(result->diff_tol, struct bn_tol);
for (i = 0; i < BU_PTBL_LEN(result->param_diffs); i++) {
struct diff_avp *avp = (struct diff_avp *)BU_PTBL_GET(result->param_diffs, i);
diff_free_avp(avp);
BU_PUT(avp, struct diff_avp);
}
bu_ptbl_free(result->param_diffs);
BU_PUT(result->param_diffs, struct bu_ptbl);
for (i = 0; i < BU_PTBL_LEN(result->attr_diffs); i++) {
struct diff_avp *avp = (struct diff_avp *)BU_PTBL_GET(result->attr_diffs, i);
diff_free_avp(avp);
BU_PUT(avp, struct diff_avp);
}
bu_ptbl_free(result->attr_diffs);
BU_PUT(result->attr_diffs, struct bu_ptbl);
}
void
diff_summarize(struct bu_vls *diff_log, const struct bu_ptbl *results, struct diff_state *state)
{
int i = 0;
struct bu_vls added_list = BU_VLS_INIT_ZERO;
struct bu_vls removed_list = BU_VLS_INIT_ZERO;
struct bu_vls changed_list = BU_VLS_INIT_ZERO;
struct bu_vls unchanged_list = BU_VLS_INIT_ZERO;
struct bu_vls added_tmp = BU_VLS_INIT_ZERO;
struct bu_vls removed_tmp = BU_VLS_INIT_ZERO;
struct bu_vls changed_tmp = BU_VLS_INIT_ZERO;
struct bu_vls unchanged_tmp = BU_VLS_INIT_ZERO;
if (state->verbosity < 1 || !results)
return;
if (state->verbosity == 1) {
if (state->return_added == 1) bu_vls_sprintf(&added_list, "Added:\n");
if (state->return_removed == 1) bu_vls_sprintf(&removed_list, "Removed:\n");
if (state->return_changed == 1) bu_vls_sprintf(&changed_list, "Changed:\n");
if (state->return_unchanged == 1) bu_vls_sprintf(&unchanged_list, "Unchanged:\n");
}
for (i = 0; i < (int)BU_PTBL_LEN(results); i++) {
int changed = 2;
struct diff_result *dr = (struct diff_result *)BU_PTBL_GET(results, i);
if (dr->param_state == DIFF_ADDED && state->return_added == 1) {
switch (state->verbosity) {
case 1:
if (strlen(bu_vls_addr(&added_tmp)) + strlen(dr->obj_name) + 2 > 80) {
bu_vls_printf(&added_list, "%s\n", bu_vls_addr(&added_tmp));
bu_vls_sprintf(&added_tmp, "%s", dr->obj_name);
} else {
if (strlen(bu_vls_addr(&added_tmp)) > 0) bu_vls_printf(&added_tmp, ", ");
bu_vls_printf(&added_tmp, "%s", dr->obj_name);
}
break;
case 2:
case 3:
bu_vls_printf(diff_log, "A %s\n", dr->obj_name);
break;
case 4:
diff_attrs_print(dr, state, diff_log);
break;
default:
break;
}
}
if (dr->param_state == DIFF_REMOVED && state->return_removed == 1) {
switch (state->verbosity) {
case 1:
if (strlen(bu_vls_addr(&removed_tmp)) + strlen(dr->obj_name) + 2 > 80) {
bu_vls_printf(&removed_list, "%s\n", bu_vls_addr(&removed_tmp));
bu_vls_sprintf(&removed_tmp, "%s", dr->obj_name);
} else {
if (strlen(bu_vls_addr(&removed_tmp)) > 0) bu_vls_printf(&removed_tmp, ", ");
bu_vls_printf(&removed_tmp, "%s", dr->obj_name);
}
break;
case 2:
case 3:
bu_vls_printf(diff_log, "D %s\n", dr->obj_name);
break;
case 4:
diff_attrs_print(dr, state, diff_log);
break;
default:
break;
}
}
if ((state->use_params || state->use_attrs) && !(state->use_params && state->use_attrs)) changed--;
if (state->use_params && ((dr->param_state == DIFF_UNCHANGED) || (dr->param_state == DIFF_UNCHANGED))) changed--;
if (state->use_attrs && ((dr->attr_state == DIFF_UNCHANGED) || (dr->attr_state == DIFF_UNCHANGED))) changed--;
if (!changed && state->return_unchanged == 1) {
switch (state->verbosity) {
case 1:
if (strlen(bu_vls_addr(&unchanged_tmp)) + strlen(dr->obj_name) + 2 > 80) {
bu_vls_printf(&unchanged_list, "%s\n", bu_vls_addr(&unchanged_tmp));
bu_vls_sprintf(&unchanged_tmp, "%s", dr->obj_name);
} else {
if (strlen(bu_vls_addr(&unchanged_tmp)) > 0) bu_vls_printf(&unchanged_tmp, ", ");
bu_vls_printf(&unchanged_tmp, "%s", dr->obj_name);
}
break;
case 2:
case 3:
bu_vls_printf(diff_log, " %s\n", dr->obj_name);
break;
case 4:
diff_attrs_print(dr, state, diff_log);
break;
default:
break;
}
}
changed = 0;
if (state->use_params) {
if (dr->param_state != DIFF_UNCHANGED && dr->param_state != DIFF_EMPTY &&
dr->param_state != DIFF_ADDED && dr->param_state != DIFF_REMOVED)
changed++;
}
if (state->use_attrs) {
if (dr->attr_state != DIFF_UNCHANGED && dr->attr_state != DIFF_EMPTY &&
dr->attr_state != DIFF_ADDED && dr->attr_state != DIFF_REMOVED)
changed++;
}
if (changed && state->return_changed == 1) {
switch (state->verbosity) {
case 1:
if (strlen(bu_vls_addr(&changed_tmp)) + strlen(dr->obj_name) + 2 > 80) {
bu_vls_printf(&changed_list, "%s\n", bu_vls_addr(&changed_tmp));
bu_vls_sprintf(&changed_tmp, "%s", dr->obj_name);
} else {
if (strlen(bu_vls_addr(&changed_tmp)) > 0) bu_vls_printf(&changed_tmp, ", ");
bu_vls_printf(&changed_tmp, "%s", dr->obj_name);
}
break;
case 2:
bu_vls_printf(diff_log, "M %s\n", dr->obj_name);
break;
case 3:
case 4:
diff_attrs_print(dr, state, diff_log);
break;
default:
break;
}
}
}
if (state->verbosity == 1) {
bu_vls_printf(&added_list, "%s\n", bu_vls_addr(&added_tmp));
bu_vls_printf(&removed_list, "%s\n", bu_vls_addr(&removed_tmp));
bu_vls_printf(&changed_list, "%s\n", bu_vls_addr(&changed_tmp));
bu_vls_printf(&unchanged_list, "%s\n", bu_vls_addr(&unchanged_tmp));
if (state->return_added == 1 && strlen(bu_vls_addr(&added_tmp)) > 0)
bu_vls_printf(diff_log, "%s\n", bu_vls_addr(&added_list));
if (state->return_removed == 1 && strlen(bu_vls_addr(&removed_tmp)) > 0)
bu_vls_printf(diff_log, "%s\n", bu_vls_addr(&removed_list));
if (state->return_changed == 1 && strlen(bu_vls_addr(&changed_tmp)) > 0)
bu_vls_printf(diff_log, "%s\n", bu_vls_addr(&changed_list));
if (state->return_unchanged == 1 && strlen(bu_vls_addr(&unchanged_tmp)) > 0)
bu_vls_printf(diff_log, "%s\n", bu_vls_addr(&unchanged_list));
}
}
int
ged_lc(struct ged *gedp, int argc, const char *argv[])
{
char *file_name = NULL;
int file_name_flag_cnt = 0;
int sort_column = 1;
int sort_column_flag_cnt = 0;
int find_duplicates_flag = 0;
int skip_special_duplicates_flag = 0;
int skip_subtracted_regions_flag = 0;
int descending_sort_flag = 0;
int unrecognized_flag_cnt = 0;
int orig_argc;
const char **orig_argv;
static const char *usage = "[-d|-s] [-r] [-z] [-0|-1|-2|-3|-4|-5] [-f {FileName}] {GroupName}";
int c;
int error_cnt = 0;
FILE *outfile = NULL;
struct bu_vls *output;
const char *group_name;
size_t i,j;
struct bu_ptbl results1 = BU_PTBL_INIT_ZERO;
struct bu_ptbl results2 = BU_PTBL_INIT_ZERO;
char *path;
char *plan;
struct db_full_path root;
int matches;
struct region_record *regions;
size_t ignored_cnt = 0;
/* The defaults are the minimum widths to accommodate column headers */
size_t region_id_len_max = 2;
size_t material_id_len_max = 3;
size_t los_len_max = 3;
size_t obj_len_max = 6;
/* For the output at the end */
size_t start, end, incr;
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s\n", usage);
return GED_HELP;
}
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
bu_optind = 1; /* re-init bu_getopt() */
while ((c = bu_getopt(argc, (char * const *)argv, "dsrz012345f:")) != -1) {
switch (c) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
sort_column_flag_cnt++;
sort_column = c - '0';
break;
case 'f':
file_name_flag_cnt++;
file_name = bu_optarg;
break;
case 's':
skip_special_duplicates_flag = 1;
/* FALLTHROUGH */
case 'd':
find_duplicates_flag = 1;
break;
case 'r':
skip_subtracted_regions_flag = 1;
break;
case 'z':
descending_sort_flag = 1;
break;
default:
unrecognized_flag_cnt++;
}
}
orig_argc = argc;
orig_argv = argv;
argc -= (bu_optind - 1);
argv += (bu_optind - 1);
/* Attempt to recreate the exact error messages from the original lc.tcl */
if (file_name_flag_cnt > 1) {
bu_vls_printf(gedp->ged_result_str, "Error: '-f' used more than once.\n");
error_cnt++;
}
if (sort_column_flag_cnt > 1) {
bu_vls_printf(gedp->ged_result_str, "Error: Sort column defined more than once.\n");
error_cnt++;
}
if (file_name_flag_cnt + argc + unrecognized_flag_cnt > 3) {
bu_vls_printf(gedp->ged_result_str, "Error: More than one group name and/or file name was specified.\n");
error_cnt++;
} else if (argc < 2) {
if (file_name_flag_cnt && !file_name) {
bu_vls_printf(gedp->ged_result_str, "Error: Group name and file name not specified\n");
} else {
bu_vls_printf(gedp->ged_result_str, "Error: Group name not specified.\n");
}
error_cnt++;
} else if (argc + unrecognized_flag_cnt > 2) {
bu_vls_printf(gedp->ged_result_str, "Error: More than one group name was specified.\n");
error_cnt++;
} else if (file_name_flag_cnt && !file_name) {
bu_vls_printf(gedp->ged_result_str, "Error: File name not specified.\n");
error_cnt++;
}
if (file_name) {
char *norm_name;
norm_name = bu_realpath(file_name, NULL);
if (file_name[0] == '-') {
bu_vls_printf(gedp->ged_result_str, "Error: File name can not start with '-'.\n");
error_cnt++;
} else if (bu_file_exists(file_name, NULL)) {
bu_vls_printf(gedp->ged_result_str, "Error: Output file %s already exists.\n",norm_name);
error_cnt++;
} else {
outfile = fopen(file_name, "w");
if (!outfile) {
bu_vls_printf(gedp->ged_result_str, "Error: %d\n", errno);
error_cnt++;
}
}
bu_vls_printf(gedp->ged_result_str, "Output filename: %s\n", norm_name);
bu_free(norm_name, "ged_lc");
output = bu_vls_vlsinit();
} else {
output = gedp->ged_result_str;
}
if (error_cnt > 0) { return GED_ERROR; }
group_name = argv[1];
/* The 7 is for the "-name" and '\0' */
plan = (char *) bu_malloc(sizeof(char) * (strlen(group_name) + 7), "ged_lc");
sprintf(plan, "-name %s", group_name);
matches = db_search(&results1, DB_SEARCH_TREE, plan, 0, NULL, gedp->ged_wdbp->dbip);
if (matches < 1) {
bu_vls_printf(gedp->ged_result_str, "Error: Group '%s' does not exist.\n", group_name);
return GED_ERROR;
}
bu_free(plan, "ged_lc");
db_search_free(&results1);
if (skip_subtracted_regions_flag) {
plan = "-type region ! -bool -";
} else {
plan = "-type region";
}
path = (char *) bu_malloc(sizeof(char) * (strlen(group_name) + 2), "ged_lc");
sprintf(path, "/%s", group_name);
db_string_to_path(&root, gedp->ged_wdbp->dbip, path);
matches = db_search(&results2, DB_SEARCH_TREE, plan, root.fp_len, root.fp_names, gedp->ged_wdbp->dbip);
bu_free(path, "ged_lc");
if (matches < 1) { return GED_ERROR; }
regions = (struct region_record *) bu_malloc(sizeof(struct region_record) * BU_PTBL_LEN(&results2), "ged_lc");
for (i = 0; i < BU_PTBL_LEN(&results2); i++) {
struct db_full_path *entry = (struct db_full_path *)BU_PTBL_GET(&results2, i);
struct directory *dp_curr_dir = DB_FULL_PATH_CUR_DIR(entry);
struct bu_attribute_value_set avs;
j = BU_PTBL_LEN(&results2) - i - 1 ;
regions[j].ignore = 0;
bu_avs_init_empty(&avs);
db5_get_attributes(gedp->ged_wdbp->dbip, &avs, dp_curr_dir);
regions[j].region_id = get_attr(&avs, "region_id");
V_MAX(region_id_len_max, strlen(regions[j].region_id));
regions[j].material_id = get_attr(&avs, "material_id");
V_MAX(material_id_len_max, strlen(regions[j].material_id));
regions[j].los = get_attr(&avs, "los");
V_MAX(los_len_max, strlen(regions[j].los));
regions[j].obj_name = dp_curr_dir->d_namep;
V_MAX(obj_len_max, strlen(regions[j].obj_name));
if (entry->fp_len > 1) {
struct directory *dp_parent = DB_FULL_PATH_GET(entry, entry->fp_len - 2);
regions[j].obj_parent = dp_parent->d_namep;
} else {
regions[j].obj_parent = "--";
}
}
if (find_duplicates_flag) {
bu_sort((void *) regions, BU_PTBL_LEN(&results2), sizeof(struct region_record), cmp_regions, NULL);
for (i = 1; i < BU_PTBL_LEN(&results2); i++) {
int same;
if (skip_special_duplicates_flag) {
same = !cmp_regions((void *)&(regions[i - 1]), (void *)&(regions[i]), NULL);
} else {
same = !bu_strcmp(regions[i - 1].region_id, regions[i].region_id);
}
if (same) {
regions[i].ignore = 1;
ignored_cnt++;
}
}
if (ignored_cnt == BU_PTBL_LEN(&results2)) {
if (file_name) {
print_cmd_args(output, orig_argc, orig_argv);
bu_vls_printf(output, "No duplicate region_id\n");
bu_vls_fwrite(outfile, output);
fclose(outfile);
}
bu_vls_printf(gedp->ged_result_str, "No duplicate region_id\n");
bu_vls_printf(gedp->ged_result_str, "Done.\n");
bu_free(regions, "ged_lc");
return GED_ERROR;
}
}
if (sort_column > 0) {
bu_sort((void *) regions, BU_PTBL_LEN(&results2), sizeof(struct region_record), sort_regions, (void *)&sort_column);
}
if (file_name) {
print_cmd_args(output, orig_argc, orig_argv);
}
bu_vls_printf(output, "List length: %d\n", BU_PTBL_LEN(&results2) - ignored_cnt);
bu_vls_printf(output, "%-*s %-*s %-*s %-*s %s\n",
region_id_len_max + 1, "ID",
material_id_len_max + 1, "MAT",
los_len_max, "LOS",
obj_len_max, "REGION",
"PARENT");
end = BU_PTBL_LEN(&results2);
if (descending_sort_flag) {
start = end - 1; end = -1; incr = -1;
} else {
start = 0; incr = 1;
}
for (i = start; i != end; i += incr) {
if (regions[i].ignore) { continue; }
bu_vls_printf(output, "%-*s %-*s %-*s %-*s %s\n",
region_id_len_max + 1, regions[i].region_id,
material_id_len_max + 1, regions[i].material_id,
los_len_max, regions[i].los,
obj_len_max, regions[i].obj_name,
regions[i].obj_parent);
}
bu_vls_printf(gedp->ged_result_str, "Done.\n");
if (file_name) {
bu_vls_fwrite(outfile, output);
fclose(outfile);
}
bu_free(regions, "ged_lc");
return GED_OK;
}
int
main( int argc, char *argv[] )
{
struct application *ap;
int c;
int verbose = 0;
int i, j;
int grid_size = 64;
fastf_t cell_size;
vect_t model_size;
vect_t xdir, zdir;
int job_count=0;
char **result_map = NULL;
struct bu_ptbl objs;
int my_session_id;
int do_plot=0;
struct timeval startTime;
struct timeval endTime;
double diff;
point_t mdl_min;
point_t mdl_max;
struct bu_vlb *vlb;
/* Things like bu_malloc() must have these initialized for use with parallel processing */
bu_semaphore_init( RT_SEM_LAST );
/* initialize the list of BRL-CAD objects to be raytraced (this is used for the "-o" option) */
bu_ptbl_init( &objs, 64, "objects" );
/* process command line args */
while ( (c=bu_getopt( argc, argv, "vps:o:" ) ) != -1 ) {
switch ( c ) {
case 'p': /* do print plot */
do_plot = 1;
break;
case 's': /* set the grid size (default is 64x64) */
grid_size = atoi( bu_optarg );
break;
case 'v': /* turn on verbose logging */
verbose = 1;
rts_set_verbosity( 1 );
break;
case 'o': /* add an object name to the list of BRL-CAD objects to raytrace */
bu_ptbl_ins( &objs, (long *)bu_optarg );
break;
default: /* ERROR */
bu_exit(1, usage, argv[0]);
}
}
if (bu_debug & BU_DEBUG_MEM_CHECK) {
bu_prmem("initial memory map");
bu_mem_barriercheck();
}
/* shoot a ray ten times, cleaning and loading geometry each time */
for(i=0 ; i<10 ; i++) {
/* load geometry */
my_session_id = loadGeometry( argv[bu_optind], &objs );
if ( my_session_id < 0 ) {
bu_exit(2, "Failed to load geometry from file (%s)\n", argv[bu_optind] );
}
get_model_extents( my_session_id, mdl_min, mdl_max );
VSET( xdir, 1, 0, 0 );
VSET( zdir, 0, 0, 1 );
VSUB2( model_size, mdl_max, mdl_min );
ap = NULL;
getApplication(&ap);
VJOIN2( ap->a_ray.r_pt, mdl_min,
model_size[Z]/2.0, zdir,
model_size[X]/2.0, xdir );
VSET( ap->a_ray.r_dir, 0, 1, 0 );
rts_shootray(ap);
vlb = (struct bu_vlb*)ap->a_uptr;
printHits(vlb);
freeApplication(ap);
/*rts_clean( my_session_id );*/
bu_log( "\n\n********* %d\n", i);
if (bu_debug & BU_DEBUG_MEM_CHECK) {
bu_prmem("memory after shutdown");
}
}
my_session_id = loadGeometry( argv[bu_optind], &objs );
/* submit some jobs */
fprintf( stderr, "\nfiring a grid (%dx%d) of rays at",
grid_size, grid_size );
for ( i=0; i<(int)BU_PTBL_LEN( &objs ); i++ ) {
fprintf( stderr, " %s", (char *)BU_PTBL_GET( &objs, i ) );
}
fprintf( stderr, "...\n" );
if( do_plot ) {
result_map = (char **)bu_calloc( grid_size, sizeof( char *), "result_map" );
for ( i=0; i<grid_size; i++ ) {
result_map[i] = (char *)bu_calloc( (grid_size+1), sizeof( char ), "result_map[i]" );
}
}
cell_size = model_size[X] / grid_size;
gettimeofday( &startTime, NULL );
for ( i=0; i<grid_size; i++ ) {
if( verbose ) {
fprintf( stderr, "shooting row %d\n", i );
}
for ( j=0; j<grid_size; j++ ) {
int hitCount;
getApplication(&ap);
ap->a_user = my_session_id;
VJOIN2( ap->a_ray.r_pt,
mdl_min,
i*cell_size,
zdir,
j*cell_size,
xdir );
ap->a_ray.index = ap->a_user;
VSET( ap->a_ray.r_dir, 0, 1, 0 );
rts_shootray(ap);
if( do_plot ) {
hitCount = countHits(ap->a_uptr);
if ( hitCount == 0 ) {
result_map[i][j] = ' ';
} else if ( hitCount <= 9 ) {
result_map[i][j] = '0' + hitCount;
} else {
result_map[i][j] = '*';
}
}
freeApplication(ap);
job_count++;
}
}
gettimeofday( &endTime, NULL );
diff = endTime.tv_sec - startTime.tv_sec + (endTime.tv_usec - startTime.tv_usec) / 1000000.0;
fprintf( stderr, "time for %d individual rays: %g second\n", job_count, diff );
if(do_plot) {
for ( i=grid_size-1; i>=0; i-- ) {
fprintf( stderr, "%s\n", result_map[i] );
}
}
return 0;
}
int
main(int argc, char **argv)
{
int i = 0;
int diff_state = 0;
struct bu_ptbl results;
struct db_i *dbip1 = DBI_NULL;
struct db_i *dbip2 = DBI_NULL;
/*struct bu_vls diff_log = BU_VLS_INIT_ZERO;*/
struct bn_tol *diff_tol;
BU_GET(diff_tol, struct bn_tol);
diff_tol->dist = BN_TOL_DIST;
BU_PTBL_INIT(&results);
if (argc != 3) {
bu_log("Error - please specify two .g files\n");
bu_exit(EXIT_FAILURE, NULL);
}
if (!bu_file_exists(argv[1], NULL)) {
bu_exit(1, "Cannot stat file %s\n", argv[1]);
}
if (!bu_file_exists(argv[2], NULL)) {
bu_exit(1, "Cannot stat file %s\n", argv[2]);
}
if ((dbip1 = db_open(argv[1], DB_OPEN_READONLY)) == DBI_NULL) {
bu_exit(1, "Cannot open geometry database file %s\n", argv[1]);
}
RT_CK_DBI(dbip1);
if (db_dirbuild(dbip1) < 0) {
db_close(dbip1);
bu_exit(1, "db_dirbuild failed on geometry database file %s\n", argv[1]);
}
/* Reset the material head so we don't get warnings when the global
* is overwritten. This will go away when material_head ceases to
* be a librt global.*/
rt_new_material_head(MATER_NULL);
if ((dbip2 = db_open(argv[2], DB_OPEN_READONLY)) == DBI_NULL) {
bu_exit(1, "Cannot open geometry database file %s\n", argv[2]);
}
RT_CK_DBI(dbip2);
if (db_dirbuild(dbip2) < 0) {
db_close(dbip1);
db_close(dbip2);
bu_exit(1, "db_dirbuild failed on geometry database file %s\n", argv[1]);
}
diff_state = db_diff(dbip1, dbip2, diff_tol, DB_COMPARE_ALL, &results);
if (diff_state == DIFF_UNCHANGED) {
bu_log("No differences found.\n");
} else {
print_diff_summary(&results);
}
for (i = 0; i < (int)BU_PTBL_LEN(&results); i++) {
struct diff_result *result = (struct diff_result *)BU_PTBL_GET(&results, i);
diff_free_result(result);
}
bu_ptbl_free(&results);
BU_PUT(diff_tol, struct bn_tol);
db_close(dbip1);
db_close(dbip2);
return 0;
}
static int
selection_command(
struct ged *gedp,
struct rt_db_internal *ip,
int argc,
const char *argv[])
{
int i;
struct rt_selection_set *selection_set;
struct bu_ptbl *selections;
struct rt_selection *new_selection;
struct rt_selection_query query;
const char *cmd, *solid_name, *selection_name;
/* 0 1 2 3
* brep <solid_name> selection subcommand
*/
if (argc < 4) {
return -1;
}
solid_name = argv[1];
cmd = argv[3];
if (BU_STR_EQUAL(cmd, "append")) {
/* append to named selection - selection is created if it doesn't exist */
void (*free_selection)(struct rt_selection *);
/* 4 5 6 7 8 9 10
* selection_name startx starty startz dirx diry dirz
*/
if (argc != 11) {
bu_log("wrong args for selection append");
return -1;
}
selection_name = argv[4];
/* find matching selections */
query.start[X] = atof(argv[5]);
query.start[Y] = atof(argv[6]);
query.start[Z] = atof(argv[7]);
query.dir[X] = atof(argv[8]);
query.dir[Y] = atof(argv[9]);
query.dir[Z] = atof(argv[10]);
query.sorting = RT_SORT_CLOSEST_TO_START;
selection_set = ip->idb_meth->ft_find_selections(ip, &query);
if (!selection_set) {
bu_log("no matching selections");
return -1;
}
/* could be multiple options, just grabbing the first and
* freeing the rest
*/
selections = &selection_set->selections;
new_selection = (struct rt_selection *)BU_PTBL_GET(selections, 0);
free_selection = selection_set->free_selection;
for (i = BU_PTBL_LEN(selections) - 1; i > 0; --i) {
long *s = BU_PTBL_GET(selections, i);
free_selection((struct rt_selection *)s);
bu_ptbl_rm(selections, s);
}
bu_ptbl_free(selections);
BU_FREE(selection_set, struct rt_selection_set);
/* get existing/new selections set in gedp */
selection_set = ged_get_selection_set(gedp, solid_name, selection_name);
selection_set->free_selection = free_selection;
selections = &selection_set->selections;
/* TODO: Need to implement append by passing new and
* existing selection to an rt_brep_evaluate_selection.
* For now, new selection simply replaces old one.
*/
for (i = BU_PTBL_LEN(selections) - 1; i >= 0; --i) {
long *s = BU_PTBL_GET(selections, i);
free_selection((struct rt_selection *)s);
bu_ptbl_rm(selections, s);
}
bu_ptbl_ins(selections, (long *)new_selection);
} else if (BU_STR_EQUAL(cmd, "translate")) {
struct rt_selection_operation operation;
/* 4 5 6 7
* selection_name dx dy dz
*/
if (argc != 8) {
return -1;
}
selection_name = argv[4];
selection_set = ged_get_selection_set(gedp, solid_name, selection_name);
selections = &selection_set->selections;
if (BU_PTBL_LEN(selections) < 1) {
return -1;
}
for (i = 0; i < (int)BU_PTBL_LEN(selections); ++i) {
int ret;
operation.type = RT_SELECTION_TRANSLATION;
operation.parameters.tran.dx = atof(argv[5]);
operation.parameters.tran.dy = atof(argv[6]);
operation.parameters.tran.dz = atof(argv[7]);
ret = ip->idb_meth->ft_process_selection(ip, gedp->ged_wdbp->dbip,
(struct rt_selection *)BU_PTBL_GET(selections, i), &operation);
if (ret != 0) {
return ret;
}
}
}
return 0;
}
int
make_hole_in_prepped_regions(struct rt_wdb *wdbp, /* database to be modified */
struct rt_i *rtip, /* rt_i pointer for the same database */
point_t hole_start, /* center of start of hole */
vect_t hole_depth, /* depth and direction of hole */
fastf_t radius, /* radius of hole */
struct bu_ptbl *regions) /* list of region structures to which this hole
* is to be applied
*/
{
struct bu_vls tmp_name = BU_VLS_INIT_ZERO;
size_t i, base_len, count=0;
struct directory *dp;
struct rt_db_internal intern;
struct soltab *stp;
RT_CHECK_WDB(wdbp);
/* make a unique name for the RCC we will use (of the form "make_hole_%d") */
bu_vls_strcat(&tmp_name, "make_hole_");
base_len = bu_vls_strlen(&tmp_name);
bu_vls_strcat(&tmp_name, "0");
while ((db_lookup(wdbp->dbip, bu_vls_addr(&tmp_name), LOOKUP_QUIET)) != RT_DIR_NULL) {
count++;
bu_vls_trunc(&tmp_name, base_len);
bu_vls_printf(&tmp_name, "%zu", count);
}
/* build the RCC based on parameters passed in */
if (mk_rcc(wdbp, bu_vls_addr(&tmp_name), hole_start, hole_depth, radius)) {
bu_log("Failed to create hole cylinder!!!\n");
bu_vls_free(&tmp_name);
return 2;
}
/* lookup the newly created RCC */
dp=db_lookup(wdbp->dbip, bu_vls_addr(&tmp_name), LOOKUP_QUIET);
if (dp == RT_DIR_NULL) {
bu_log("Failed to lookup RCC (%s) just made by make_hole_in_prepped_regions()!!!\n",
bu_vls_addr(&tmp_name));
bu_bomb("Failed to lookup RCC just made by make_hole_in_prepped_regions()!!!\n");
}
/* get the internal form of the new RCC */
if (rt_db_get_internal(&intern, dp, wdbp->dbip, NULL, wdbp->wdb_resp) < 0) {
bu_log("Failed to get internal form of RCC (%s) just made by make_hole_in_prepped_regions()!!!\n",
bu_vls_addr(&tmp_name));
bu_bomb("Failed to get internal form of RCC just made by make_hole_in_prepped_regions()!!!\n");
}
/* Build a soltab structure for the new RCC */
BU_ALLOC(stp, struct soltab);
stp->l.magic = RT_SOLTAB_MAGIC;
stp->l2.magic = RT_SOLTAB2_MAGIC;
stp->st_uses = 1;
stp->st_dp = dp;
stp->st_bit = rtip->nsolids++;
/* Add the new soltab structure to the rt_i structure */
rtip->rti_Solids = (struct soltab **)bu_realloc(rtip->rti_Solids,
rtip->nsolids * sizeof(struct soltab *),
"new rti_Solids");
rtip->rti_Solids[stp->st_bit] = stp;
/* actually prep the new RCC */
if (intern.idb_meth->ft_prep(stp, &intern, rtip)) {
bu_log("Failed to prep RCC (%s) just made by make_hole_in_prepped_regions()!!!\n",
bu_vls_addr(&tmp_name));
bu_bomb("Failed to prep RCC just made by make_hole_in_prepped_regions()!!!\n");
}
/* initialize the soltabs list of containing regions */
bu_ptbl_init(&stp->st_regions, BU_PTBL_LEN(regions), "stp->st_regions");
/* Subtract the new RCC from each region structure in the list provided */
for (i=0; i<BU_PTBL_LEN(regions); i++) {
struct region *rp;
union tree *treep;
/* get the next region structure */
rp = (struct region *)BU_PTBL_GET(regions, i);
RT_CK_REGION(rp);
/* create a tree node for the subtraction operation, this will be the new tree root */
BU_ALLOC(treep, union tree);
RT_TREE_INIT(treep);
treep->tr_b.tb_op = OP_SUBTRACT;
treep->tr_b.tb_left = rp->reg_treetop; /* subtract from the old treetop */
treep->tr_b.tb_regionp = rp;
/* make the new node the new treetop */
rp->reg_treetop = treep;
/* create a tree node for the new RCC */
BU_ALLOC(treep, union tree);
RT_TREE_INIT(treep);
treep->tr_a.tu_op = OP_SOLID;
treep->tr_a.tu_stp = stp;
treep->tr_a.tu_regionp = rp;
/* the new RCC gets hung on the right of the subtract node */
rp->reg_treetop->tr_b.tb_right = treep;
/* make sure the "all unions" flag is not set on this region */
rp->reg_all_unions = 0;
/* Add this region to the list of containing regions for the new RCC */
bu_ptbl_ins(&stp->st_regions, (long *)rp);
}
/* insert the new RCC soltab structure into the already existing space partitioning tree */
insert_in_bsp(stp, &rtip->rti_CutHead);
return 0;
}
int
ged_draw_guts(struct ged *gedp, int argc, const char *argv[], int kind)
{
size_t i;
int drawtrees_retval;
int flag_A_attr=0;
int flag_o_nonunique=1;
int last_opt=0;
struct bu_vls vls = BU_VLS_INIT_ZERO;
static const char *usage = "<[-R -C#/#/# -s] objects> | <-o -A attribute name/value pairs>";
/* #define DEBUG_TIMING 1 */
#ifdef DEBUG_TIMING
int64_t elapsedtime;
#endif
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_DRAWABLE(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* must be wanting help */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_HELP;
}
#ifdef DEBUG_TIMING
elapsedtime = bu_gettime();
#endif
/* skip past cmd */
--argc;
++argv;
/* check args for "-A" (attributes) and "-o" */
for (i = 0; i < (size_t)argc; i++) {
char *ptr_A=NULL;
char *ptr_o=NULL;
char *c;
if (*argv[i] != '-') {
/* Done checking options. If our display is non-empty,
* add -R to keep current view.
*/
if (BU_LIST_NON_EMPTY(gedp->ged_gdp->gd_headDisplay)) {
bu_vls_strcat(&vls, " -R");
}
break;
}
ptr_A=strchr(argv[i], 'A');
if (ptr_A)
flag_A_attr = 1;
ptr_o=strchr(argv[i], 'o');
if (ptr_o)
flag_o_nonunique = 2;
last_opt = i;
if (!ptr_A && !ptr_o) {
bu_vls_putc(&vls, ' ');
bu_vls_strcat(&vls, argv[i]);
continue;
}
if (strlen(argv[i]) == ((size_t)1 + (ptr_A != NULL) + (ptr_o != NULL))) {
/* argv[i] is just a "-A" or "-o" */
continue;
}
/* copy args other than "-A" or "-o" */
bu_vls_putc(&vls, ' ');
c = (char *)argv[i];
while (*c != '\0') {
if (*c != 'A' && *c != 'o') {
bu_vls_putc(&vls, *c);
}
c++;
}
}
if (flag_A_attr) {
/* args are attribute name/value pairs */
struct bu_attribute_value_set avs;
int max_count=0;
int remaining_args=0;
int new_argc=0;
char **new_argv=NULL;
struct bu_ptbl *tbl;
remaining_args = argc - last_opt - 1;
if (remaining_args < 2 || remaining_args%2) {
bu_vls_printf(gedp->ged_result_str, "Error: must have even number of arguments (name/value pairs)\n");
bu_vls_free(&vls);
return GED_ERROR;
}
bu_avs_init(&avs, (argc - last_opt)/2, "ged_draw_guts avs");
i = 0;
while (i < (size_t)argc) {
if (*argv[i] == '-') {
i++;
continue;
}
/* this is a name/value pair */
if (flag_o_nonunique == 2) {
bu_avs_add_nonunique(&avs, argv[i], argv[i+1]);
} else {
bu_avs_add(&avs, argv[i], argv[i+1]);
}
i += 2;
}
tbl = db_lookup_by_attr(gedp->ged_wdbp->dbip, RT_DIR_REGION | RT_DIR_SOLID | RT_DIR_COMB, &avs, flag_o_nonunique);
bu_avs_free(&avs);
if (!tbl) {
bu_log("Error: db_lookup_by_attr() failed!!\n");
bu_vls_free(&vls);
return TCL_ERROR;
}
if (BU_PTBL_LEN(tbl) < 1) {
/* nothing matched, just return */
bu_vls_free(&vls);
return TCL_OK;
}
for (i = 0; i < BU_PTBL_LEN(tbl); i++) {
struct directory *dp;
dp = (struct directory *)BU_PTBL_GET(tbl, i);
bu_vls_putc(&vls, ' ');
bu_vls_strcat(&vls, dp->d_namep);
}
max_count = BU_PTBL_LEN(tbl) + last_opt + 1;
bu_ptbl_free(tbl);
bu_free((char *)tbl, "ged_draw_guts ptbl");
new_argv = (char **)bu_calloc(max_count+1, sizeof(char *), "ged_draw_guts new_argv");
new_argc = bu_argv_from_string(new_argv, max_count, bu_vls_addr(&vls));
/* First, delete any mention of these objects.
* Silently skip any leading options (which start with minus signs).
*/
for (i = 0; i < (size_t)new_argc; ++i) {
/* Skip any options */
if (new_argv[i][0] == '-') {
/* If this option requires an argument which was
* provided separately (e.g. '-C 0/255/0' instead of
* '-C0/255/0'), skip the argument too.
*/
if (strlen(argv[i]) == 2 && strchr("mxCP", argv[i][1])) {
i++;
}
continue;
}
dl_erasePathFromDisplay(gedp->ged_gdp->gd_headDisplay, gedp->ged_wdbp->dbip, gedp->ged_free_vlist_callback, new_argv[i], 0, gedp->freesolid);
}
drawtrees_retval = _ged_drawtrees(gedp, new_argc, (const char **)new_argv, kind, (struct _ged_client_data *)0);
bu_vls_free(&vls);
bu_free((char *)new_argv, "ged_draw_guts new_argv");
if (drawtrees_retval) {
return GED_ERROR;
}
} else {
int empty_display;
bu_vls_free(&vls);
empty_display = 1;
if (BU_LIST_NON_EMPTY(gedp->ged_gdp->gd_headDisplay)) {
empty_display = 0;
}
/* First, delete any mention of these objects.
* Silently skip any leading options (which start with minus signs).
*/
for (i = 0; i < (size_t)argc; ++i) {
/* Skip any options */
if (argv[i][0] == '-') {
/* If this option requires an argument which was
* provided separately (e.g. '-C 0/255/0' instead of
* '-C0/255/0'), skip the argument too.
*/
if (strlen(argv[i]) == 2 && strchr("mxCP", argv[i][1])) {
i++;
}
continue;
}
dl_erasePathFromDisplay(gedp->ged_gdp->gd_headDisplay, gedp->ged_wdbp->dbip, gedp->ged_free_vlist_callback, argv[i], 0, gedp->freesolid);
}
/* if our display is non-empty add -R to keep current view */
if (!empty_display) {
int new_argc;
char **new_argv;
new_argc = argc + 1;
new_argv = (char **)bu_malloc(new_argc * sizeof(char *), "ged_draw_guts new_argv");
new_argv[0] = bu_strdup("-R");
for (i = 0; i < (size_t)argc; ++i) {
new_argv[i + 1] = bu_strdup(argv[i]);
}
drawtrees_retval = _ged_drawtrees(gedp, new_argc, (const char **)new_argv, kind, (struct _ged_client_data *)0);
for (i = 0; i < (size_t)new_argc; ++i) {
bu_free(new_argv[i], "ged_draw_guts new_argv[i] - bu_strdup(argv[i])");
}
bu_free(new_argv, "ged_draw_guts new_argv");
} else {
drawtrees_retval = _ged_drawtrees(gedp, argc, argv, kind, (struct _ged_client_data *)0);
}
if (drawtrees_retval) {
return GED_ERROR;
}
}
#ifdef DEBUG_TIMING
elapsedtime = bu_gettime() - elapsedtime;
{
int seconds = elapsedtime / 1000000;
int minutes = seconds / 60;
int hours = minutes / 60;
minutes = minutes % 60;
seconds = seconds %60;
bu_vls_printf(gedp->ged_result_str, "Elapsed time: %02d:%02d:%02d\n", hours, minutes, seconds);
}
#endif
return GED_OK;
}
/* 0 = no difference within tolerance, 1 = difference >= tolerance */
int
analyze_raydiff(/* TODO - decide what to return. Probably some sort of left, common, right segment sets. See what rtcheck does... */
struct db_i *dbip, const char *obj1, const char *obj2, struct bn_tol *tol)
{
int ret;
int count = 0;
struct rt_i *rtip;
int ncpus = bu_avail_cpus();
point_t min, mid, max;
struct rt_pattern_data *xdata, *ydata, *zdata;
fastf_t *rays;
struct raydiff_container *state;
if (!dbip || !obj1 || !obj2 || !tol) return 0;
rtip = rt_new_rti(dbip);
if (rt_gettree(rtip, obj1) < 0) return -1;
if (rt_gettree(rtip, obj2) < 0) return -1;
rt_prep_parallel(rtip, 1);
/* Now we've got the bounding box - set up the grids */
VMOVE(min, rtip->mdl_min);
VMOVE(max, rtip->mdl_max);
VSET(mid, (max[0] - min[0])/2, (max[1] - min[1])/2, (max[2] - min[2])/2);
BU_GET(xdata, struct rt_pattern_data);
VSET(xdata->center_pt, min[0] - 0.1 * min[0], mid[1], mid[2]);
VSET(xdata->center_dir, 1, 0, 0);
xdata->vn = 2;
xdata->pn = 2;
xdata->n_vec = (vect_t *)bu_calloc(xdata->vn + 1, sizeof(vect_t), "vects array");
xdata->n_p = (fastf_t *)bu_calloc(xdata->pn + 1, sizeof(fastf_t), "params array");
xdata->n_p[0] = 50; /* TODO - get tolerances from caller */
xdata->n_p[1] = 50;
VSET(xdata->n_vec[0], 0, max[1], 0);
VSET(xdata->n_vec[1], 0, 0, max[2]);
ret = rt_pattern(xdata, RT_PATTERN_RECT_ORTHOGRID);
bu_free(xdata->n_vec, "x vec inputs");
bu_free(xdata->n_p, "x p inputs");
if (ret < 0) return -1;
BU_GET(ydata, struct rt_pattern_data);
VSET(ydata->center_pt, mid[0], min[1] - 0.1 * min[1], mid[2]);
VSET(ydata->center_dir, 0, 1, 0);
ydata->vn = 2;
ydata->pn = 2;
ydata->n_vec = (vect_t *)bu_calloc(ydata->vn + 1, sizeof(vect_t), "vects array");
ydata->n_p = (fastf_t *)bu_calloc(ydata->pn + 1, sizeof(fastf_t), "params array");
ydata->n_p[0] = 50; /* TODO - get tolerances from caller */
ydata->n_p[1] = 50;
VSET(ydata->n_vec[0], max[0], 0, 0);
VSET(ydata->n_vec[1], 0, 0, max[2]);
ret = rt_pattern(ydata, RT_PATTERN_RECT_ORTHOGRID);
bu_free(ydata->n_vec, "y vec inputs");
bu_free(ydata->n_p, "y p inputs");
if (ret < 0) return -1;
BU_GET(zdata, struct rt_pattern_data);
VSET(zdata->center_pt, mid[0], mid[1], min[2] - 0.1 * min[2]);
VSET(zdata->center_dir, 0, 0, 1);
zdata->vn = 2;
zdata->pn = 2;
zdata->n_vec = (vect_t *)bu_calloc(zdata->vn + 1, sizeof(vect_t), "vects array");
zdata->n_p = (fastf_t *)bu_calloc(zdata->pn + 1, sizeof(fastf_t), "params array");
zdata->n_p[0] = 50; /* TODO - get tolerances from caller */
zdata->n_p[1] = 50;
VSET(zdata->n_vec[0], max[0], 0, 0);
VSET(zdata->n_vec[1], 0, max[1], 0);
ret = rt_pattern(zdata, RT_PATTERN_RECT_ORTHOGRID);
bu_free(zdata->n_vec, "x vec inputs");
bu_free(zdata->n_p, "x p inputs");
if (ret < 0) return -1;
/* Consolidate the grids into a single ray array */
{
size_t i, j;
rays = (fastf_t *)bu_calloc((xdata->ray_cnt + ydata->ray_cnt + zdata->ray_cnt + 1) * 6, sizeof(fastf_t), "rays");
count = 0;
for (i = 0; i < xdata->ray_cnt; i++) {
for (j = 0; j < 6; j++) {
rays[6*count+j] = xdata->rays[6*i + j];
}
count++;
}
for (i = 0; i < ydata->ray_cnt; i++) {
for (j = 0; j < 6; j++) {
rays[6*count+j] = ydata->rays[6*i + j];
}
count++;
}
for (i = 0; i < zdata->ray_cnt; i++) {
for (j = 0; j < 6; j++) {
rays[6*count+j] = zdata->rays[6*i+j];
}
count++;
}
}
bu_free(xdata->rays, "x rays");
bu_free(ydata->rays, "y rays");
bu_free(zdata->rays, "z rays");
BU_PUT(xdata, struct rt_pattern_data);
BU_PUT(ydata, struct rt_pattern_data);
BU_PUT(zdata, struct rt_pattern_data);
bu_log("ray cnt: %d\n", count);
{
int i, j;
ncpus = 2;
state = (struct raydiff_container *)bu_calloc(ncpus+1, sizeof(struct raydiff_container), "resources");
for (i = 0; i < ncpus+1; i++) {
state[i].rtip = rtip;
state[i].tol = 0.5;
state[i].ncpus = ncpus;
state[i].left_name = bu_strdup(obj1);
state[i].right_name = bu_strdup(obj2);
BU_GET(state[i].resp, struct resource);
rt_init_resource(state[i].resp, i, state->rtip);
BU_GET(state[i].left, struct bu_ptbl);
bu_ptbl_init(state[i].left, 64, "left solid hits");
BU_GET(state[i].both, struct bu_ptbl);
bu_ptbl_init(state[i].both, 64, "hits on both solids");
BU_GET(state[i].right, struct bu_ptbl);
bu_ptbl_init(state[i].right, 64, "right solid hits");
state[i].rays_cnt = count;
state[i].rays = rays;
}
bu_parallel(raydiff_gen_worker, ncpus, (void *)state);
/* Collect and print all of the results */
for (i = 0; i < ncpus+1; i++) {
for (j = 0; j < (int)BU_PTBL_LEN(state[i].left); j++) {
struct diff_seg *dseg = (struct diff_seg *)BU_PTBL_GET(state[i].left, j);
bu_log("Result: LEFT diff vol (%s): %g %g %g -> %g %g %g\n", obj1, V3ARGS(dseg->in_pt), V3ARGS(dseg->out_pt));
}
for (j = 0; j < (int)BU_PTBL_LEN(state[i].both); j++) {
struct diff_seg *dseg = (struct diff_seg *)BU_PTBL_GET(state[i].both, j);
bu_log("Result: BOTH): %g %g %g -> %g %g %g\n", V3ARGS(dseg->in_pt), V3ARGS(dseg->out_pt));
}
for (j = 0; j < (int)BU_PTBL_LEN(state[i].right); j++) {
struct diff_seg *dseg = (struct diff_seg *)BU_PTBL_GET(state[i].right, j);
bu_log("Result: RIGHT diff vol (%s): %g %g %g -> %g %g %g\n", obj2, V3ARGS(dseg->in_pt), V3ARGS(dseg->out_pt));
}
}
/* Free results */
for (i = 0; i < ncpus+1; i++) {
for (j = 0; j < (int)BU_PTBL_LEN(state[i].left); j++) {
struct diff_seg *dseg = (struct diff_seg *)BU_PTBL_GET(state[i].left, j);
BU_PUT(dseg, struct diff_seg);
}
bu_ptbl_free(state[i].left);
BU_PUT(state[i].left, struct diff_seg);
for (j = 0; j < (int)BU_PTBL_LEN(state[i].both); j++) {
struct diff_seg *dseg = (struct diff_seg *)BU_PTBL_GET(state[i].both, j);
BU_PUT(dseg, struct diff_seg);
}
bu_ptbl_free(state[i].both);
BU_PUT(state[i].both, struct diff_seg);
for (j = 0; j < (int)BU_PTBL_LEN(state[i].right); j++) {
struct diff_seg *dseg = (struct diff_seg *)BU_PTBL_GET(state[i].right, j);
BU_PUT(dseg, struct diff_seg);
}
bu_ptbl_free(state[i].right);
BU_PUT(state[i].right, struct diff_seg);
bu_free((void *)state[i].left_name, "left name");
bu_free((void *)state[i].right_name, "right name");
BU_PUT(state[i].resp, struct resource);
}
bu_free(state, "free state containers");
}
return 0;
}
static void
nmg_to_dxf(struct nmgregion *r, const struct db_full_path *pathp, int UNUSED(region_id), int UNUSED(material_id), float color[3])
{
struct model *m;
struct shell *s;
struct vertex *v;
struct bu_ptbl verts;
char *region_name;
int region_polys=0;
int tri_count=0;
int color_num;
int do_triangulate=0;
NMG_CK_REGION(r);
RT_CK_FULL_PATH(pathp);
region_name = db_path_to_string(pathp);
m = r->m_p;
NMG_CK_MODEL(m);
/* Count triangles */
for (BU_LIST_FOR(s, shell, &r->s_hd)) {
struct faceuse *fu;
NMG_CK_SHELL(s);
for (BU_LIST_FOR(fu, faceuse, &s->fu_hd)) {
struct loopuse *lu;
int vert_count=0;
NMG_CK_FACEUSE(fu);
if (fu->orientation != OT_SAME)
continue;
for (BU_LIST_FOR(lu, loopuse, &fu->lu_hd)) {
struct edgeuse *eu;
if (BU_LIST_FIRST_MAGIC(&lu->down_hd) != NMG_EDGEUSE_MAGIC)
continue;
for (BU_LIST_FOR(eu, edgeuse, &lu->down_hd)) {
vert_count++;
}
if (vert_count > 3) {
do_triangulate = 1;
goto triangulate;
}
tri_count++;
}
}
}
triangulate:
if (do_triangulate) {
/* triangulate model */
nmg_triangulate_model(m, &tol);
/* Count triangles */
tri_count = 0;
for (BU_LIST_FOR(s, shell, &r->s_hd)) {
struct faceuse *fu;
for (BU_LIST_FOR(fu, faceuse, &s->fu_hd)) {
struct loopuse *lu;
if (fu->orientation != OT_SAME)
continue;
for (BU_LIST_FOR(lu, loopuse, &fu->lu_hd)) {
if (BU_LIST_FIRST_MAGIC(&lu->down_hd) != NMG_EDGEUSE_MAGIC)
continue;
tri_count++;
}
}
}
}
nmg_vertex_tabulate(&verts, &r->l.magic);
color_num = find_closest_color(color);
if (polyface_mesh) {
size_t i;
fprintf(fp, "0\nPOLYLINE\n8\n%s\n62\n%d\n70\n64\n71\n%lu\n72\n%d\n",
region_name, color_num, (unsigned long)BU_PTBL_LEN(&verts), tri_count);
for (i = 0; i < BU_PTBL_LEN(&verts); i++) {
fprintf(fp, "0\nVERTEX\n8\n%s\n", region_name);
v = (struct vertex *)BU_PTBL_GET(&verts, i);
NMG_CK_VERTEX(v);
if (inches) {
fprintf(fp, "10\n%f\n20\n%f\n30\n%f\n70\n192\n", V3ARGSIN(v->vg_p->coord));
} else {
fprintf(fp, "10\n%f\n20\n%f\n30\n%f\n70\n192\n", V3ARGS(v->vg_p->coord));
}
}
}
/* Check triangles */
for (BU_LIST_FOR(s, shell, &r->s_hd)) {
struct faceuse *fu;
NMG_CK_SHELL(s);
for (BU_LIST_FOR(fu, faceuse, &s->fu_hd)) {
struct loopuse *lu;
NMG_CK_FACEUSE(fu);
if (fu->orientation != OT_SAME)
continue;
for (BU_LIST_FOR(lu, loopuse, &fu->lu_hd)) {
struct edgeuse *eu;
int vert_count=0;
NMG_CK_LOOPUSE(lu);
if (BU_LIST_FIRST_MAGIC(&lu->down_hd) != NMG_EDGEUSE_MAGIC)
continue;
if (polyface_mesh) {
fprintf(fp, "0\nVERTEX\n8\n%s\n70\n128\n10\n0.0\n20\n0.0\n30\n0.0\n",
region_name);
} else {
fprintf(fp, "0\n3DFACE\n8\n%s\n62\n%d\n", region_name, color_num);
}
/* check vertex numbers for each triangle */
for (BU_LIST_FOR(eu, edgeuse, &lu->down_hd)) {
NMG_CK_EDGEUSE(eu);
vert_count++;
v = eu->vu_p->v_p;
NMG_CK_VERTEX(v);
if (polyface_mesh) {
fprintf(fp, "%d\n%d\n",
vert_count+70, bu_ptbl_locate(&verts, (long *)v) + 1);
} else {
if (inches) {
fprintf(fp, "%d\n%f\n%d\n%f\n%d\n%f\n",
10 + vert_count - 1,
v->vg_p->coord[X] / 25.4,
20 + vert_count - 1,
v->vg_p->coord[Y] / 25.4,
30 + vert_count -1,
v->vg_p->coord[Z] / 25.4);
} else {
fprintf(fp, "%d\n%f\n%d\n%f\n%d\n%f\n",
10 + vert_count - 1,
v->vg_p->coord[X],
20 + vert_count - 1,
v->vg_p->coord[Y],
30 + vert_count -1,
v->vg_p->coord[Z]);
}
}
}
if (vert_count > 3) {
bu_free(region_name, "region name");
bu_log("lu %p has %d vertices!\n", (void *)lu, vert_count);
bu_exit(1, "ERROR: LU is not a triangle\n");
} else if (vert_count < 3) {
continue;
} else {
/* repeat the last vertex for the benefit of codes
* that interpret the dxf specification for
* 3DFACES as requiring a fourth vertex even when
* only three are input.
*/
if (!polyface_mesh) {
vert_count++;
if (inches) {
fprintf(fp, "%d\n%f\n%d\n%f\n%d\n%f\n",
10 + vert_count - 1,
v->vg_p->coord[X] / 25.4,
20 + vert_count - 1,
v->vg_p->coord[Y] / 25.4,
30 + vert_count -1,
v->vg_p->coord[Z] / 25.4);
} else {
fprintf(fp, "%d\n%f\n%d\n%f\n%d\n%f\n",
10 + vert_count - 1,
v->vg_p->coord[X],
20 + vert_count - 1,
v->vg_p->coord[Y],
30 + vert_count -1,
v->vg_p->coord[Z]);
}
}
}
tot_polygons++;
region_polys++;
}
}
}
bu_ptbl_free(&verts);
bu_free(region_name, "region name");
if (polyface_mesh) {
fprintf(fp, "0\nSEQEND\n");
}
}