Revision: 75002
http://sourceforge.net/p/brlcad/code/75002
Author: starseeker
Date: 2020-03-09 15:57:59 +0000 (Mon, 09 Mar 2020)
Log Message:
-----------
refactor
Modified Paths:
--------------
brlcad/trunk/src/libanalyze/nirt/diff.cpp
brlcad/trunk/src/libanalyze/nirt/nirt.cpp
brlcad/trunk/src/libanalyze/nirt/nirt.h
Modified: brlcad/trunk/src/libanalyze/nirt/diff.cpp
===================================================================
--- brlcad/trunk/src/libanalyze/nirt/diff.cpp 2020-03-09 14:47:01 UTC (rev
75001)
+++ brlcad/trunk/src/libanalyze/nirt/diff.cpp 2020-03-09 15:57:59 UTC (rev
75002)
@@ -100,33 +100,48 @@
fastf_t gap_los_delta;
};
+
+struct nirt_diff_state;
+
struct nirt_diff {
point_t orig;
vect_t dir;
- std::vector<struct nirt_seg *> old_segs;
- std::vector<struct nirt_seg *> new_segs;
- std::vector<struct nirt_seg_diff *> diffs;
+ std::vector<struct nirt_seg> old_segs;
+ std::vector<struct nirt_seg> new_segs;
+ std::vector<struct nirt_seg_diff> diffs;
+ struct nirt_diff_state *nds;
};
-struct nirt_diff_settings {
- int report_partitions;
- int report_misses;
- int report_gaps;
- int report_overlaps;
- int report_partition_reg_ids;
- int report_partition_reg_names;
- int report_partition_path_names;
- int report_partition_dists;
- int report_partition_obliq;
- int report_overlap_reg_names;
- int report_overlap_reg_ids;
- int report_overlap_dists;
- int report_overlap_obliq;
- int report_gap_dists;
- fastf_t dist_delta_tol;
- fastf_t obliq_delta_tol;
- fastf_t los_delta_tol;
- fastf_t scaled_los_delta_tol;
+struct nirt_diff_state {
+
+ struct bu_vls diff_file = BU_VLS_INIT_ZERO;
+ struct nirt_diff *cdiff = NULL;
+ std::vector<struct nirt_diff> diffs;
+ bool diff_ready = false;
+
+ /* Reporting settings */
+ bool report_partitions = true;
+ bool report_misses = true;
+ bool report_gaps = true;
+ bool report_overlaps = true;
+ bool report_partition_reg_ids = true;
+ bool report_partition_reg_names = true;
+ bool report_partition_path_names = true;
+ bool report_partition_dists = true;
+ bool report_partition_obliq = true;
+ bool report_overlap_reg_names = true;
+ bool report_overlap_reg_ids = true;
+ bool report_overlap_dists = true;
+ bool report_overlap_obliq = true;
+ bool report_gap_dists = true;
+
+ /* Tolerances */
+ fastf_t dist_delta_tol = BN_TOL_DIST;
+ fastf_t obliq_delta_tol = BN_TOL_DIST;
+ fastf_t los_delta_tol = BN_TOL_DIST;
+ fastf_t scaled_los_delta_tol = BN_TOL_DIST;
+
+ struct nirt_state *nss;
};
@@ -133,62 +148,32 @@
void
_nirt_diff_create(struct nirt_state *nss)
{
- BU_GET(nss->i->diff_file, struct bu_vls);
- bu_vls_init(nss->i->diff_file);
- nss->i->cdiff = NULL;
- nss->i->diff_run = 0;
- nss->i->diff_ready = 0;
- BU_GET(nss->i->diff_settings, struct nirt_diff_settings);
- nss->i->diff_settings->report_partitions = 1;
- nss->i->diff_settings->report_misses = 1;
- nss->i->diff_settings->report_gaps = 1;
- nss->i->diff_settings->report_overlaps = 1;
- nss->i->diff_settings->report_partition_reg_ids = 1;
- nss->i->diff_settings->report_partition_reg_names = 1;
- nss->i->diff_settings->report_partition_path_names = 1;
- nss->i->diff_settings->report_partition_dists = 1;
- nss->i->diff_settings->report_partition_obliq = 1;
- nss->i->diff_settings->report_overlap_reg_names = 1;
- nss->i->diff_settings->report_overlap_reg_ids = 1;
- nss->i->diff_settings->report_overlap_dists = 1;
- nss->i->diff_settings->report_overlap_obliq = 1;
- nss->i->diff_settings->report_gap_dists = 1;
- nss->i->diff_settings->dist_delta_tol = BN_TOL_DIST;
- nss->i->diff_settings->obliq_delta_tol = BN_TOL_DIST;
- nss->i->diff_settings->los_delta_tol = BN_TOL_DIST;
- nss->i->diff_settings->scaled_los_delta_tol = BN_TOL_DIST;
+ nss->i->diff_state = new nirt_diff_state;
+ nss->i->diff_state->nss = nss;
}
void
_nirt_diff_destroy(struct nirt_state *nss)
{
- bu_vls_free(nss->i->diff_file);
- BU_PUT(nss->i->diff_settings, struct nirt_diff_settings);
+ bu_vls_free(&nss->i->diff_state->diff_file);
+ // TODO - clean up nirt_diff objects
+ delete nss->i->diff_state;
}
void
_nirt_diff_add_seg(struct nirt_state *nss, struct nirt_seg *nseg)
{
- if (nss->i->cdiff && nss->i->diff_run) {
- nss->i->cdiff->new_segs.push_back(_nirt_seg_cpy(nseg));
+ if (nss->i->diff_state && nss->i->diff_state->cdiff) {
+ nss->i->diff_state->cdiff->new_segs.push_back(*nseg);
}
}
-#define SD_INIT(sd, l, r) \
- do {BU_GET(sd, struct nirt_seg_diff); sd->left = left; sd->right = right;}
\
- while (0)
-
-#define SD_FREE(sd) \
- do {BU_PUT(sd, struct nirt_seg_diff);} \
- while (0)
-
-
-static struct nirt_seg_diff *
-_nirt_partition_diff(struct nirt_state *nss, struct nirt_seg *left, struct
nirt_seg *right)
+static bool
+_nirt_partition_diff(struct nirt_diff *ndiff, struct nirt_seg *left, struct
nirt_seg *right)
{
int have_diff = 0;
- struct nirt_seg_diff *sd;
- if (!nss || !nss->i->diff_settings) return NULL;
+ struct nirt_seg_diff sd;
+ if (!ndiff || !ndiff->nds) return false;
fastf_t in_delta = DIST_PNT_PNT(left->in, right->in);
fastf_t out_delta = DIST_PNT_PNT(left->in, right->in);
fastf_t los_delta = fabs(left->los - right->los);
@@ -198,31 +183,33 @@
if (bu_vls_strcmp(left->reg_name, right->reg_name)) have_diff = 1;
if (bu_vls_strcmp(left->path_name, right->path_name)) have_diff = 1;
if (left->reg_id != right->reg_id) have_diff = 1;
- if (in_delta > nss->i->diff_settings->dist_delta_tol) have_diff = 1;
- if (out_delta > nss->i->diff_settings->dist_delta_tol) have_diff = 1;
- if (los_delta > nss->i->diff_settings->los_delta_tol) have_diff = 1;
- if (scaled_los_delta > nss->i->diff_settings->scaled_los_delta_tol)
have_diff = 1;
- if (obliq_in_delta > nss->i->diff_settings->obliq_delta_tol) have_diff = 1;
- if (obliq_out_delta > nss->i->diff_settings->obliq_delta_tol) have_diff =
1;
+ if (in_delta > ndiff->nds->dist_delta_tol) have_diff = 1;
+ if (out_delta > ndiff->nds->dist_delta_tol) have_diff = 1;
+ if (los_delta > ndiff->nds->los_delta_tol) have_diff = 1;
+ if (scaled_los_delta > ndiff->nds->scaled_los_delta_tol) have_diff = 1;
+ if (obliq_in_delta > ndiff->nds->obliq_delta_tol) have_diff = 1;
+ if (obliq_out_delta > ndiff->nds->obliq_delta_tol) have_diff = 1;
if (have_diff) {
- SD_INIT(sd, left, right);
- sd->in_delta = in_delta;
- sd->out_delta = out_delta;
- sd->los_delta = los_delta;
- sd->scaled_los_delta = scaled_los_delta;
- sd->obliq_in_delta = obliq_in_delta;
- sd->obliq_out_delta = obliq_out_delta;
- return sd;
+ sd.left = left;
+ sd.right = right;
+ sd.in_delta = in_delta;
+ sd.out_delta = out_delta;
+ sd.los_delta = los_delta;
+ sd.scaled_los_delta = scaled_los_delta;
+ sd.obliq_in_delta = obliq_in_delta;
+ sd.obliq_out_delta = obliq_out_delta;
+ ndiff->diffs.push_back(sd);
+ return true;
}
- return NULL;
+ return false;
}
-static struct nirt_seg_diff *
-_nirt_overlap_diff(struct nirt_state *nss, struct nirt_seg *left, struct
nirt_seg *right)
+static bool
+_nirt_overlap_diff(struct nirt_diff *ndiff, struct nirt_seg *left, struct
nirt_seg *right)
{
int have_diff = 0;
- struct nirt_seg_diff *sd;
- if (!nss || !nss->i->diff_settings) return NULL;
+ struct nirt_seg_diff sd;
+ if (!ndiff || !ndiff->nds) return false;
fastf_t ov_in_delta = DIST_PNT_PNT(left->ov_in, right->ov_in);
fastf_t ov_out_delta = DIST_PNT_PNT(left->ov_out, right->ov_out);
fastf_t ov_los_delta = fabs(left->ov_los - right->ov_los);
@@ -230,60 +217,66 @@
if (bu_vls_strcmp(left->ov_reg2_name, right->ov_reg2_name)) have_diff = 1;
if (left->ov_reg1_id != right->ov_reg1_id) have_diff = 1;
if (left->ov_reg2_id != right->ov_reg2_id) have_diff = 1;
- if (ov_in_delta > nss->i->diff_settings->dist_delta_tol) have_diff = 1;
- if (ov_out_delta > nss->i->diff_settings->dist_delta_tol) have_diff = 1;
- if (ov_los_delta > nss->i->diff_settings->los_delta_tol) have_diff = 1;
+ if (ov_in_delta > ndiff->nds->dist_delta_tol) have_diff = 1;
+ if (ov_out_delta > ndiff->nds->dist_delta_tol) have_diff = 1;
+ if (ov_los_delta > ndiff->nds->los_delta_tol) have_diff = 1;
if (have_diff) {
- SD_INIT(sd, left, right);
- sd->ov_in_delta = ov_in_delta;
- sd->ov_out_delta = ov_out_delta;
- sd->ov_los_delta = ov_los_delta;
- return sd;
+ sd.left = left;
+ sd.right = right;
+ sd.ov_in_delta = ov_in_delta;
+ sd.ov_out_delta = ov_out_delta;
+ sd.ov_los_delta = ov_los_delta;
+ ndiff->diffs.push_back(sd);
+ return true;
}
- return NULL;
+ return false;
}
-static struct nirt_seg_diff *
-_nirt_gap_diff(struct nirt_state *nss, struct nirt_seg *left, struct nirt_seg
*right)
+static bool
+_nirt_gap_diff(struct nirt_diff *ndiff, struct nirt_seg *left, struct nirt_seg
*right)
{
int have_diff = 0;
- struct nirt_seg_diff *sd;
- if (!nss || !nss->i->diff_settings) return NULL;
+ struct nirt_seg_diff sd;
+ if (!ndiff || !ndiff->nds) return false;
fastf_t gap_in_delta = DIST_PNT_PNT(left->gap_in, right->gap_in);
fastf_t gap_los_delta = fabs(left->gap_los - right->gap_los);
- if (gap_in_delta > nss->i->diff_settings->dist_delta_tol) have_diff = 1;
- if (gap_los_delta > nss->i->diff_settings->los_delta_tol) have_diff = 1;
+ if (gap_in_delta > ndiff->nds->dist_delta_tol) have_diff = 1;
+ if (gap_los_delta > ndiff->nds->los_delta_tol) have_diff = 1;
if (have_diff) {
- SD_INIT(sd, left, right);
- sd->gap_in_delta = gap_in_delta;
- sd->gap_los_delta = gap_los_delta;
- return sd;
+ sd.left = left;
+ sd.right = right;
+ sd.gap_in_delta = gap_in_delta;
+ sd.gap_los_delta = gap_los_delta;
+ ndiff->diffs.push_back(sd);
+ return true;
}
- return 0;
+ return false;
}
-static struct nirt_seg_diff *
-_nirt_segs_diff(struct nirt_state *nss, struct nirt_seg *left, struct nirt_seg
*right)
+static bool
+_nirt_segs_diff(struct nirt_diff *ndiff, struct nirt_seg *left, struct
nirt_seg *right)
{
- struct nirt_seg_diff *sd;
- if (!nss) return NULL;
+ if (!ndiff) return NULL;
if (!left || !right || left->type != right->type) {
/* Fundamental segment difference - no point going further, they're
different */
- SD_INIT(sd, left, right);
- return sd;
+ struct nirt_seg_diff sd;
+ sd.left = left;
+ sd.right = right;
+ ndiff->diffs.push_back(sd);
+ return true;
}
switch(left->type) {
case NIRT_MISS_SEG:
/* Types don't differ and they're both misses - we're good */
- return NULL;
+ return false;
case NIRT_PARTITION_SEG:
- return _nirt_partition_diff(nss, left, right);
+ return _nirt_partition_diff(ndiff, left, right);
case NIRT_GAP_SEG:
- return _nirt_gap_diff(nss, left, right);
+ return _nirt_gap_diff(ndiff, left, right);
case NIRT_OVERLAP_SEG:
- return _nirt_overlap_diff(nss, left, right);
+ return _nirt_overlap_diff(ndiff, left, right);
default:
- nerr(nss, "NIRT diff error: unknown segment type: %d\n",
left->type);
+ nerr(ndiff->nds->nss, "NIRT diff error: unknown segment type:
%d\n", left->type);
return 0;
}
}
@@ -315,26 +308,29 @@
int did_header = 0;
struct bu_vls dreport = BU_VLS_INIT_ZERO;
- if (!nss || nss->i->diffs.size() == 0) return 0;
- std::vector<struct nirt_diff *> *dfs = &(nss->i->diffs);
- for (size_t i = 0; i < dfs->size(); i++) {
- struct nirt_diff *d = (*dfs)[i];
+ if (!nss) return 0;
+
+ struct nirt_diff_state *nds = nss->i->diff_state;
+
+ if (!nds || nds->diffs.size() == 0) return 0;
+ std::vector<struct nirt_diff> &dfs = nds->diffs;
+ for (size_t i = 0; i < dfs.size(); i++) {
+ struct nirt_diff *d = &(dfs[i]);
// Calculate diffs according to settings. TODO - need to be more
sophisticated about this - if a
// segment is "missing" but the rays otherwise match, don't propagate
the "offset" and report all
// of the subsequent segments as different...
size_t seg_max = (d->old_segs.size() > d->new_segs.size()) ?
d->new_segs.size() : d->old_segs.size();
for (size_t j = 0; j < seg_max; j++) {
- struct nirt_seg_diff *sd = _nirt_segs_diff(nss, d->old_segs[j],
d->new_segs[j]);
- if (sd) d->diffs.push_back(sd);
+ _nirt_segs_diff(d, &d->old_segs[j], &d->new_segs[j]);
}
if (d->diffs.size() > 0 && !did_header) {
- bu_vls_printf(&dreport, "Diff Results (%s):\n",
bu_vls_addr(nss->i->diff_file));
+ bu_vls_printf(&dreport, "Diff Results (%s):\n",
bu_vls_addr(&nds->diff_file));
did_header = 1;
}
if (d->diffs.size() > 0) bu_vls_printf(&dreport, "Found differences
along Ray:\n xyz %.17f %.17f %.17f\n dir %.17f %.17f %.17f\n \n",
V3ARGS(d->orig), V3ARGS(d->dir));
for (size_t j = 0; j < d->diffs.size(); j++) {
- struct nirt_seg_diff *sd = d->diffs[j];
+ struct nirt_seg_diff *sd = &d->diffs[j];
struct nirt_seg *left = sd->left;
struct nirt_seg *right = sd->right;
if (left->type != right->type) {
@@ -345,100 +341,100 @@
}
switch (sd->left->type) {
case NIRT_MISS_SEG:
- if (!nss->i->diff_settings->report_misses) continue;
+ if (!nds->report_misses) continue;
/* TODO */
break;
case NIRT_PARTITION_SEG:
- if (!nss->i->diff_settings->report_partitions) continue;
+ if (!nds->report_partitions) continue;
bu_vls_printf(&dreport, " Segment difference(%s)[%zu]:\n",
_nirt_seg_string(sd->left->type), j);
- if (bu_vls_strcmp(left->reg_name, right->reg_name) &&
nss->i->diff_settings->report_partition_reg_names) {
+ if (bu_vls_strcmp(left->reg_name, right->reg_name) &&
nds->report_partition_reg_names) {
bu_vls_printf(&dreport, " Region Name: '%s' ->
'%s'\n", bu_vls_addr(left->reg_name), bu_vls_addr(right->reg_name));
reporting_diff = 1;
}
- if (bu_vls_strcmp(left->path_name, right->path_name) &&
nss->i->diff_settings->report_partition_path_names) {
+ if (bu_vls_strcmp(left->path_name, right->path_name) &&
nds->report_partition_path_names) {
bu_vls_printf(&dreport, " Path Name: '%s' ->
'%s'\n", bu_vls_addr(left->path_name), bu_vls_addr(right->path_name));
reporting_diff = 1;
}
- if (left->reg_id != right->reg_id &&
nss->i->diff_settings->report_partition_reg_ids) {
+ if (left->reg_id != right->reg_id &&
nds->report_partition_reg_ids) {
bu_vls_printf(&dreport, " Region ID: %d -> %d\n",
left->reg_id, right->reg_id);
reporting_diff = 1;
}
- if (sd->in_delta > nss->i->diff_settings->dist_delta_tol &&
nss->i->diff_settings->report_partition_dists) {
- std::string oval = _nirt_dbl_to_str(sd->in_delta,
_nirt_digits(nss->i->diff_settings->dist_delta_tol));
+ if (sd->in_delta > nds->dist_delta_tol &&
nds->report_partition_dists) {
+ std::string oval = _nirt_dbl_to_str(sd->in_delta,
_nirt_digits(nds->dist_delta_tol));
bu_vls_printf(&dreport, "
DIST_PNT_PNT(in_old,in_new): %s\n", oval.c_str());
reporting_diff = 1;
}
- if (sd->out_delta > nss->i->diff_settings->dist_delta_tol
&& nss->i->diff_settings->report_partition_dists) {
- std::string oval = _nirt_dbl_to_str(sd->out_delta,
_nirt_digits(nss->i->diff_settings->dist_delta_tol));
+ if (sd->out_delta > nds->dist_delta_tol &&
nds->report_partition_dists) {
+ std::string oval = _nirt_dbl_to_str(sd->out_delta,
_nirt_digits(nds->dist_delta_tol));
bu_vls_printf(&dreport, "
DIST_PNT_PNT(out_old,out_new): %s\n", oval.c_str());
reporting_diff = 1;
}
- if (sd->los_delta > nss->i->diff_settings->los_delta_tol &&
nss->i->diff_settings->report_partition_dists) {
- std::string oval = _nirt_dbl_to_str(sd->los_delta,
_nirt_digits(nss->i->diff_settings->los_delta_tol));
+ if (sd->los_delta > nds->los_delta_tol &&
nds->report_partition_dists) {
+ std::string oval = _nirt_dbl_to_str(sd->los_delta,
_nirt_digits(nds->los_delta_tol));
bu_vls_printf(&dreport, " Line-Of-Sight(LOS) %s:
%s\n", delta_str, oval.c_str());
reporting_diff = 1;
}
- if (sd->scaled_los_delta >
nss->i->diff_settings->scaled_los_delta_tol &&
nss->i->diff_settings->report_partition_dists) {
- std::string oval =
_nirt_dbl_to_str(sd->scaled_los_delta,
_nirt_digits(nss->i->diff_settings->los_delta_tol));
+ if (sd->scaled_los_delta > nds->scaled_los_delta_tol &&
nds->report_partition_dists) {
+ std::string oval =
_nirt_dbl_to_str(sd->scaled_los_delta, _nirt_digits(nds->los_delta_tol));
bu_vls_printf(&dreport, " Scaled Line-Of-Sight %s:
%s\n", delta_str, oval.c_str());
reporting_diff = 1;
}
- if (sd->obliq_in_delta >
nss->i->diff_settings->obliq_delta_tol &&
nss->i->diff_settings->report_partition_obliq) {
- std::string oval = _nirt_dbl_to_str(sd->obliq_in_delta,
_nirt_digits(nss->i->diff_settings->obliq_delta_tol));
+ if (sd->obliq_in_delta > nds->obliq_delta_tol &&
nds->report_partition_obliq) {
+ std::string oval = _nirt_dbl_to_str(sd->obliq_in_delta,
_nirt_digits(nds->obliq_delta_tol));
bu_vls_printf(&dreport, " Input Normal Obliquity %s:
%s\n", delta_str, oval.c_str());
reporting_diff = 1;
}
- if (sd->obliq_out_delta >
nss->i->diff_settings->obliq_delta_tol &&
nss->i->diff_settings->report_partition_obliq) {
- std::string oval =
_nirt_dbl_to_str(sd->obliq_out_delta,
_nirt_digits(nss->i->diff_settings->obliq_delta_tol));
+ if (sd->obliq_out_delta > nds->obliq_delta_tol &&
nds->report_partition_obliq) {
+ std::string oval =
_nirt_dbl_to_str(sd->obliq_out_delta, _nirt_digits(nds->obliq_delta_tol));
bu_vls_printf(&dreport, " Output Normal Obliquity
%s: %s\n", delta_str, oval.c_str());
reporting_diff = 1;
}
break;
case NIRT_GAP_SEG:
- if (!nss->i->diff_settings->report_gaps) continue;
+ if (!nds->report_gaps) continue;
bu_vls_printf(&dreport, " Segment difference(%s)[%zu]:\n",
_nirt_seg_string(sd->left->type), j);
- if (sd->gap_in_delta >
nss->i->diff_settings->dist_delta_tol &&
nss->i->diff_settings->report_gap_dists) {
- std::string oval = _nirt_dbl_to_str(sd->gap_in_delta,
_nirt_digits(nss->i->diff_settings->dist_delta_tol));
+ if (sd->gap_in_delta > nds->dist_delta_tol &&
nds->report_gap_dists) {
+ std::string oval = _nirt_dbl_to_str(sd->gap_in_delta,
_nirt_digits(nds->dist_delta_tol));
bu_vls_printf(&dreport, "
DIST_PNT_PNT(gap_in_old,gap_in_new): %s\n", oval.c_str());
reporting_diff = 1;
}
- if (sd->gap_los_delta >
nss->i->diff_settings->los_delta_tol &&
nss->i->diff_settings->report_gap_dists) {
- std::string oval = _nirt_dbl_to_str(sd->gap_los_delta,
_nirt_digits(nss->i->diff_settings->los_delta_tol));
+ if (sd->gap_los_delta > nds->los_delta_tol &&
nds->report_gap_dists) {
+ std::string oval = _nirt_dbl_to_str(sd->gap_los_delta,
_nirt_digits(nds->los_delta_tol));
bu_vls_printf(&dreport, " Gap Line-Of-Sight (LOS)
%s: %s\n", delta_str, oval.c_str());
reporting_diff = 1;
}
break;
case NIRT_OVERLAP_SEG:
- if (!nss->i->diff_settings->report_overlaps) continue;
+ if (!nds->report_overlaps) continue;
bu_vls_printf(&dreport, " Segment difference(%s)[%zu]:\n",
_nirt_seg_string(sd->left->type), j);
- if (bu_vls_strcmp(left->ov_reg1_name, right->ov_reg1_name)
&& nss->i->diff_settings->report_overlap_reg_names) {
+ if (bu_vls_strcmp(left->ov_reg1_name, right->ov_reg1_name)
&& nds->report_overlap_reg_names) {
bu_vls_printf(&dreport, " Region 1 Name: '%s' ->
'%s'\n", bu_vls_addr(left->ov_reg1_name), bu_vls_addr(right->ov_reg1_name));
reporting_diff = 1;
}
- if (bu_vls_strcmp(left->ov_reg2_name, right->ov_reg2_name)
&& nss->i->diff_settings->report_overlap_reg_names) {
+ if (bu_vls_strcmp(left->ov_reg2_name, right->ov_reg2_name)
&& nds->report_overlap_reg_names) {
bu_vls_printf(&dreport, " Region 2 Name: '%s' ->
'%s'\n", bu_vls_addr(left->ov_reg2_name), bu_vls_addr(right->ov_reg2_name));
reporting_diff = 1;
}
- if (left->ov_reg1_id != right->ov_reg1_id &&
nss->i->diff_settings->report_overlap_reg_ids) {
+ if (left->ov_reg1_id != right->ov_reg1_id &&
nds->report_overlap_reg_ids) {
bu_vls_printf(&dreport, " Region 1 ID: %d -> %d\n",
left->ov_reg1_id, right->ov_reg1_id);
reporting_diff = 1;
}
- if (left->ov_reg2_id != right->ov_reg2_id &&
nss->i->diff_settings->report_overlap_reg_ids) {
+ if (left->ov_reg2_id != right->ov_reg2_id &&
nds->report_overlap_reg_ids) {
bu_vls_printf(&dreport, " Region 2 ID: %d -> %d\n",
left->ov_reg2_id, right->ov_reg2_id);
reporting_diff = 1;
}
- if (sd->ov_in_delta > nss->i->diff_settings->dist_delta_tol
&& nss->i->diff_settings->report_overlap_dists) {
- std::string oval = _nirt_dbl_to_str(sd->ov_in_delta,
_nirt_digits(nss->i->diff_settings->dist_delta_tol));
+ if (sd->ov_in_delta > nds->dist_delta_tol &&
nds->report_overlap_dists) {
+ std::string oval = _nirt_dbl_to_str(sd->ov_in_delta,
_nirt_digits(nds->dist_delta_tol));
bu_vls_printf(&dreport, " DIST_PNT_PNT(ov_in_old,
ov_in_new): %s\n", oval.c_str());
reporting_diff = 1;
}
- if (sd->ov_out_delta >
nss->i->diff_settings->dist_delta_tol &&
nss->i->diff_settings->report_overlap_dists) {
- std::string oval = _nirt_dbl_to_str(sd->ov_out_delta,
_nirt_digits(nss->i->diff_settings->dist_delta_tol));
+ if (sd->ov_out_delta > nds->dist_delta_tol &&
nds->report_overlap_dists) {
+ std::string oval = _nirt_dbl_to_str(sd->ov_out_delta,
_nirt_digits(nds->dist_delta_tol));
bu_vls_printf(&dreport, " DIST_PNT_PNT(ov_out_old,
ov_out_new): %s\n", oval.c_str());
reporting_diff = 1;
}
- if (sd->ov_los_delta > nss->i->diff_settings->los_delta_tol
&& nss->i->diff_settings->report_overlap_dists) {
- std::string oval = _nirt_dbl_to_str(sd->ov_los_delta,
_nirt_digits(nss->i->diff_settings->los_delta_tol));
+ if (sd->ov_los_delta > nds->los_delta_tol &&
nds->report_overlap_dists) {
+ std::string oval = _nirt_dbl_to_str(sd->ov_los_delta,
_nirt_digits(nds->los_delta_tol));
bu_vls_printf(&dreport, " Overlap Line-Of-Sight
(LOS) %s: %s\n", delta_str, oval.c_str());
reporting_diff = 1;
}
@@ -448,9 +444,6 @@
return 0;
}
}
- for (size_t j = 0; j < d->diffs.size(); j++) {
- SD_FREE(d->diffs[j]);
- }
d->diffs.clear();
}
@@ -471,6 +464,7 @@
{
if (!ns) return -1;
struct nirt_state *nss = (struct nirt_state *)ns;
+ struct nirt_diff_state *nds = nss->i->diff_state;
int ac = 0;
int print_help = 0;
double tol = 0;
@@ -512,7 +506,7 @@
return -1;
}
- if (nss->i->diff_ready) {
+ if (nds->diff_ready) {
nerr(nss, "Diff file already loaded. To reset, run \"diff
clear\"\n");
return -1;
}
@@ -537,11 +531,10 @@
nss->i->ap->a_resource = _nirt_get_resource(nss);
}
- bu_vls_sprintf(nss->i->diff_file, "%s", argv[0]);
- nss->i->diff_run = 1;
+ bu_vls_sprintf(&nds->diff_file, "%s", argv[0]);
+ // TODO - temporarily suppress all formatting output for a silent diff
run...
have_ray = 0;
while (std::getline(ifs, line)) {
- struct nirt_diff *df;
/* If part of the line is commented, skip that part */
cmt = _nirt_find_first_unescaped(line, "#", 0);
@@ -581,10 +574,10 @@
// TODO - rethink this container...
_nirt_init_ovlp(nss);
(void)rt_shootray(nss->i->ap);
- nss->i->diffs.push_back(nss->i->cdiff);
}
// Read ray
- df = new struct nirt_diff;
+ struct nirt_diff df;
+ df.nds = nds;
// TODO - once we go to C++11, used std::regex_search and
std::smatch to more flexibly get a substring
std::string rstr = line.substr(7);
have_ray = 1;
@@ -591,21 +584,21 @@
std::vector<std::string> substrs = _nirt_string_split(rstr);
if (substrs.size() != 6) {
nerr(nss, "Error processing ray line \"%s\"!\nExpected 6
elements, found %zu\n", line.c_str(), substrs.size());
- delete df;
return -1;
}
- VSET(df->orig, _nirt_str_to_dbl(substrs[0], 0),
_nirt_str_to_dbl(substrs[1], 0), _nirt_str_to_dbl(substrs[2], 0));
- VSET(df->dir, _nirt_str_to_dbl(substrs[3], 0),
_nirt_str_to_dbl(substrs[4], 0), _nirt_str_to_dbl(substrs[5], 0));
- VMOVE(nss->i->vals->dir, df->dir);
- VMOVE(nss->i->vals->orig, df->orig);
+ VSET(df.orig, _nirt_str_to_dbl(substrs[0], 0),
_nirt_str_to_dbl(substrs[1], 0), _nirt_str_to_dbl(substrs[2], 0));
+ VSET(df.dir, _nirt_str_to_dbl(substrs[3], 0),
_nirt_str_to_dbl(substrs[4], 0), _nirt_str_to_dbl(substrs[5], 0));
+ VMOVE(nss->i->vals->dir, df.dir);
+ VMOVE(nss->i->vals->orig, df.orig);
#ifdef NIRT_DIFF_DEBUG
bu_log("Found RAY:\n");
- bu_log("origin : %0.17f, %0.17f, %0.17f\n", V3ARGS(df->orig));
- bu_log("direction: %0.17f, %0.17f, %0.17f\n", V3ARGS(df->dir));
+ bu_log("origin : %0.17f, %0.17f, %0.17f\n", V3ARGS(df.orig));
+ bu_log("direction: %0.17f, %0.17f, %0.17f\n", V3ARGS(df.dir));
#endif
_nirt_targ2grid(nss);
_nirt_dir2ae(nss);
- nss->i->cdiff = df;
+ nds->diffs.push_back(df);
+ nds->cdiff = &nds->diffs[nds->diffs.size() - 1];
continue;
}
@@ -623,33 +616,35 @@
nerr(nss, "Error processing hit line \"%s\"!\nExpected 15
elements, found %zu\n", hstr.c_str(), substrs.size());
return -1;
}
- struct nirt_seg *seg;
- _nirt_seg_init(&seg);
- seg->type = NIRT_PARTITION_SEG;
- bu_vls_decode(seg->reg_name, substrs[0].c_str());
- //bu_vls_printf(seg->reg_name, "%s", substrs[0].c_str());
- bu_vls_decode(seg->path_name, substrs[1].c_str());
- seg->reg_id = _nirt_str_to_int(substrs[2]);
- VSET(seg->in, _nirt_str_to_dbl(substrs[3], 0),
_nirt_str_to_dbl(substrs[4], 0), _nirt_str_to_dbl(substrs[5], 0));
- seg->d_in = _nirt_str_to_dbl(substrs[6], 0);
- VSET(seg->out, _nirt_str_to_dbl(substrs[7], 0),
_nirt_str_to_dbl(substrs[8], 0), _nirt_str_to_dbl(substrs[9], 0));
- seg->d_out = _nirt_str_to_dbl(substrs[10], 0);
- seg->los = _nirt_str_to_dbl(substrs[11], 0);
- seg->scaled_los = _nirt_str_to_dbl(substrs[12], 0);
- seg->obliq_in = _nirt_str_to_dbl(substrs[13], 0);
- seg->obliq_out = _nirt_str_to_dbl(substrs[14], 0);
+
+ struct nirt_seg seg;
+ struct nirt_seg *segp = &seg;
+ _nirt_seg_init(&segp);
+ seg.type = NIRT_PARTITION_SEG;
+ bu_vls_decode(seg.reg_name, substrs[0].c_str());
+ //bu_vls_printf(seg.reg_name, "%s", substrs[0].c_str());
+ bu_vls_decode(seg.path_name, substrs[1].c_str());
+ seg.reg_id = _nirt_str_to_int(substrs[2]);
+ VSET(seg.in, _nirt_str_to_dbl(substrs[3], 0),
_nirt_str_to_dbl(substrs[4], 0), _nirt_str_to_dbl(substrs[5], 0));
+ seg.d_in = _nirt_str_to_dbl(substrs[6], 0);
+ VSET(seg.out, _nirt_str_to_dbl(substrs[7], 0),
_nirt_str_to_dbl(substrs[8], 0), _nirt_str_to_dbl(substrs[9], 0));
+ seg.d_out = _nirt_str_to_dbl(substrs[10], 0);
+ seg.los = _nirt_str_to_dbl(substrs[11], 0);
+ seg.scaled_los = _nirt_str_to_dbl(substrs[12], 0);
+ seg.obliq_in = _nirt_str_to_dbl(substrs[13], 0);
+ seg.obliq_out = _nirt_str_to_dbl(substrs[14], 0);
#ifdef NIRT_DIFF_DEBUG
bu_log("Found %s:\n", line.c_str());
- bu_log(" reg_name: %s\n", bu_vls_addr(seg->reg_name));
- bu_log(" path_name: %s\n", bu_vls_addr(seg->path_name));
- bu_log(" reg_id: %d\n", seg->reg_id);
- bu_log(" in: %0.17f, %0.17f, %0.17f\n", V3ARGS(seg->in));
- bu_log(" out: %0.17f, %0.17f, %0.17f\n", V3ARGS(seg->out));
- bu_log(" d_in: %0.17f d_out: %0.17f\n", seg->d_in, seg->d_out);
- bu_log(" los: %0.17f scaled_los: %0.17f\n", seg->los,
seg->scaled_los);
- bu_log(" obliq_in: %0.17f obliq_out: %0.17f\n",
seg->obliq_in, seg->obliq_out);
+ bu_log(" reg_name: %s\n", bu_vls_addr(seg.reg_name));
+ bu_log(" path_name: %s\n", bu_vls_addr(seg.path_name));
+ bu_log(" reg_id: %d\n", seg.reg_id);
+ bu_log(" in: %0.17f, %0.17f, %0.17f\n", V3ARGS(seg.in));
+ bu_log(" out: %0.17f, %0.17f, %0.17f\n", V3ARGS(seg.out));
+ bu_log(" d_in: %0.17f d_out: %0.17f\n", seg.d_in, seg.d_out);
+ bu_log(" los: %0.17f scaled_los: %0.17f\n", seg.los,
seg.scaled_los);
+ bu_log(" obliq_in: %0.17f obliq_out: %0.17f\n", seg.obliq_in,
seg.obliq_out);
#endif
- nss->i->cdiff->old_segs.push_back(seg);
+ nds->cdiff->old_segs.push_back(seg);
continue;
}
@@ -667,19 +662,20 @@
nerr(nss, "Error processing gap line \"%s\"!\nExpected 7
elements, found %zu\n", gstr.c_str(), substrs.size());
return -1;
}
- struct nirt_seg *seg;
- _nirt_seg_init(&seg);
- seg->type = NIRT_GAP_SEG;
- VSET(seg->gap_in, _nirt_str_to_dbl(substrs[0], 0),
_nirt_str_to_dbl(substrs[1], 0), _nirt_str_to_dbl(substrs[2], 0));
- VSET(seg->in, _nirt_str_to_dbl(substrs[3], 0),
_nirt_str_to_dbl(substrs[4], 0), _nirt_str_to_dbl(substrs[5], 0));
- seg->gap_los = _nirt_str_to_dbl(substrs[6], 0);
+ struct nirt_seg seg;
+ struct nirt_seg *segp = &seg;
+ _nirt_seg_init(&segp);
+ seg.type = NIRT_GAP_SEG;
+ VSET(seg.gap_in, _nirt_str_to_dbl(substrs[0], 0),
_nirt_str_to_dbl(substrs[1], 0), _nirt_str_to_dbl(substrs[2], 0));
+ VSET(seg.in, _nirt_str_to_dbl(substrs[3], 0),
_nirt_str_to_dbl(substrs[4], 0), _nirt_str_to_dbl(substrs[5], 0));
+ seg.gap_los = _nirt_str_to_dbl(substrs[6], 0);
#ifdef NIRT_DIFF_DEBUG
bu_log("Found %s:\n", line.c_str());
- bu_log(" in: %0.17f, %0.17f, %0.17f\n", V3ARGS(seg->gap_in));
- bu_log(" out: %0.17f, %0.17f, %0.17f\n", V3ARGS(seg->in));
- bu_log(" gap_los: %0.17f\n", seg->gap_los);
+ bu_log(" in: %0.17f, %0.17f, %0.17f\n", V3ARGS(seg.gap_in));
+ bu_log(" out: %0.17f, %0.17f, %0.17f\n", V3ARGS(seg.in));
+ bu_log(" gap_los: %0.17f\n", seg.gap_los);
#endif
- nss->i->cdiff->old_segs.push_back(seg);
+ nds->cdiff->old_segs.push_back(seg);
continue;
}
@@ -690,14 +686,15 @@
return -1;
}
- struct nirt_seg *seg;
- _nirt_seg_init(&seg);
- seg->type = NIRT_MISS_SEG;
+ struct nirt_seg seg;
+ struct nirt_seg *segp = &seg;
+ _nirt_seg_init(&segp);
+ seg.type = NIRT_MISS_SEG;
#ifdef NIRT_DIFF_DEBUG
bu_log("Found MISS\n");
#endif
have_ray = 0;
- nss->i->cdiff->old_segs.push_back(seg);
+ nds->cdiff->old_segs.push_back(seg);
continue;
}
@@ -715,27 +712,28 @@
nerr(nss, "Error processing overlap line \"%s\"!\nExpected
11 elements, found %zu\n", ostr.c_str(), substrs.size());
return -1;
}
- struct nirt_seg *seg;
- _nirt_seg_init(&seg);
- seg->type = NIRT_OVERLAP_SEG;
- bu_vls_decode(seg->ov_reg1_name, substrs[0].c_str());
- bu_vls_decode(seg->ov_reg2_name, substrs[1].c_str());
- seg->ov_reg1_id = _nirt_str_to_int(substrs[2]);
- seg->ov_reg2_id = _nirt_str_to_int(substrs[3]);
- VSET(seg->ov_in, _nirt_str_to_dbl(substrs[4], 0),
_nirt_str_to_dbl(substrs[5], 0), _nirt_str_to_dbl(substrs[6], 0));
- VSET(seg->ov_out, _nirt_str_to_dbl(substrs[7], 0),
_nirt_str_to_dbl(substrs[8], 0), _nirt_str_to_dbl(substrs[9], 0));
- seg->ov_los = _nirt_str_to_dbl(substrs[10], 0);
+ struct nirt_seg seg;
+ struct nirt_seg *segp = &seg;
+ _nirt_seg_init(&segp);
+ seg.type = NIRT_OVERLAP_SEG;
+ bu_vls_decode(seg.ov_reg1_name, substrs[0].c_str());
+ bu_vls_decode(seg.ov_reg2_name, substrs[1].c_str());
+ seg.ov_reg1_id = _nirt_str_to_int(substrs[2]);
+ seg.ov_reg2_id = _nirt_str_to_int(substrs[3]);
+ VSET(seg.ov_in, _nirt_str_to_dbl(substrs[4], 0),
_nirt_str_to_dbl(substrs[5], 0), _nirt_str_to_dbl(substrs[6], 0));
+ VSET(seg.ov_out, _nirt_str_to_dbl(substrs[7], 0),
_nirt_str_to_dbl(substrs[8], 0), _nirt_str_to_dbl(substrs[9], 0));
+ seg.ov_los = _nirt_str_to_dbl(substrs[10], 0);
#ifdef NIRT_DIFF_DEBUG
bu_log("Found %s:\n", line.c_str());
- bu_log(" ov_reg1_name: %s\n", bu_vls_addr(seg->ov_reg1_name));
- bu_log(" ov_reg2_name: %s\n", bu_vls_addr(seg->ov_reg2_name));
- bu_log(" ov_reg1_id: %d\n", seg->ov_reg1_id);
- bu_log(" ov_reg2_id: %d\n", seg->ov_reg2_id);
- bu_log(" ov_in: %0.17f, %0.17f, %0.17f\n", V3ARGS(seg->ov_in));
- bu_log(" ov_out: %0.17f, %0.17f, %0.17f\n",
V3ARGS(seg->ov_out));
- bu_log(" ov_los: %0.17f\n", seg->ov_los);
+ bu_log(" ov_reg1_name: %s\n", bu_vls_addr(seg.ov_reg1_name));
+ bu_log(" ov_reg2_name: %s\n", bu_vls_addr(seg.ov_reg2_name));
+ bu_log(" ov_reg1_id: %d\n", seg.ov_reg1_id);
+ bu_log(" ov_reg2_id: %d\n", seg.ov_reg2_id);
+ bu_log(" ov_in: %0.17f, %0.17f, %0.17f\n", V3ARGS(seg.ov_in));
+ bu_log(" ov_out: %0.17f, %0.17f, %0.17f\n",
V3ARGS(seg.ov_out));
+ bu_log(" ov_los: %0.17f\n", seg.ov_los);
#endif
- nss->i->cdiff->old_segs.push_back(seg);
+ nds->cdiff->old_segs.push_back(seg);
continue;
}
#ifdef NIRT_DIFF_DEBUG
@@ -752,7 +750,6 @@
// TODO - rethink this container...
_nirt_init_ovlp(nss);
(void)rt_shootray(nss->i->ap);
- nss->i->diffs.push_back(nss->i->cdiff);
// Thought - if we have rays but no pre-defined output, write out
the
// expected output to stdout - in this mode diff will generate a
diff
@@ -762,15 +759,14 @@
ifs.close();
// Done with if_hit and friends
- nss->i->cdiff = NULL;
- nss->i->diff_run = 0;
- nss->i->diff_ready = 1;
+ nds->cdiff = NULL;
+ nds->diff_ready = 1;
return 0;
}
if (BU_STR_EQUAL(argv[0], "report")) {
// Report diff results according to the NIRT diff settings.
- if (!nss->i->diff_ready) {
+ if (!nds->diff_ready) {
nerr(nss, "No diff file loaded - please load a diff file with
\"diff load <filename>\"\n");
return -1;
} else {
@@ -779,19 +775,8 @@
}
if (BU_STR_EQUAL(argv[0], "clear")) {
- // need clear command to scrub old nss->i->diffs
- for (size_t i = 0; i < nss->i->diffs.size(); i++) {
- struct nirt_diff *df = nss->i->diffs[i];
- for (size_t j = 0; j < df->old_segs.size(); j++) {
- _nirt_seg_free(df->old_segs[j]);
- }
- for (size_t j = 0; j < df->new_segs.size(); j++) {
- _nirt_seg_free(df->new_segs[j]);
- }
- delete nss->i->diffs[i];
- }
- nss->i->diffs.clear();
- nss->i->diff_ready = 0;
+ nds->diffs.clear();
+ nds->diff_ready = false;
return 0;
}
@@ -799,74 +784,74 @@
ac--; argv++;
if (!ac) {
//print current settings
- nout(nss, "report_partitions: %d\n",
nss->i->diff_settings->report_partitions);
- nout(nss, "report_misses: %d\n",
nss->i->diff_settings->report_misses);
- nout(nss, "report_gaps: %d\n",
nss->i->diff_settings->report_gaps);
- nout(nss, "report_overlaps: %d\n",
nss->i->diff_settings->report_overlaps);
- nout(nss, "report_partition_reg_ids: %d\n",
nss->i->diff_settings->report_partition_reg_ids);
- nout(nss, "report_partition_reg_names: %d\n",
nss->i->diff_settings->report_partition_reg_names);
- nout(nss, "report_partition_path_names: %d\n",
nss->i->diff_settings->report_partition_path_names);
- nout(nss, "report_partition_dists: %d\n",
nss->i->diff_settings->report_partition_dists);
- nout(nss, "report_partition_obliq: %d\n",
nss->i->diff_settings->report_partition_obliq);
- nout(nss, "report_overlap_reg_names: %d\n",
nss->i->diff_settings->report_overlap_reg_names);
- nout(nss, "report_overlap_reg_ids: %d\n",
nss->i->diff_settings->report_overlap_reg_ids);
- nout(nss, "report_overlap_dists: %d\n",
nss->i->diff_settings->report_overlap_dists);
- nout(nss, "report_overlap_obliq: %d\n",
nss->i->diff_settings->report_overlap_obliq);
- nout(nss, "report_gap_dists: %d\n",
nss->i->diff_settings->report_gap_dists);
- nout(nss, "dist_delta_tol: %g\n",
nss->i->diff_settings->dist_delta_tol);
- nout(nss, "obliq_delta_tol: %g\n",
nss->i->diff_settings->obliq_delta_tol);
- nout(nss, "los_delta_tol: %g\n",
nss->i->diff_settings->los_delta_tol);
- nout(nss, "scaled_los_delta_tol: %g\n",
nss->i->diff_settings->scaled_los_delta_tol);
+ nout(nss, "report_partitions: %d\n",
nds->report_partitions);
+ nout(nss, "report_misses: %d\n", nds->report_misses);
+ nout(nss, "report_gaps: %d\n", nds->report_gaps);
+ nout(nss, "report_overlaps: %d\n",
nds->report_overlaps);
+ nout(nss, "report_partition_reg_ids: %d\n",
nds->report_partition_reg_ids);
+ nout(nss, "report_partition_reg_names: %d\n",
nds->report_partition_reg_names);
+ nout(nss, "report_partition_path_names: %d\n",
nds->report_partition_path_names);
+ nout(nss, "report_partition_dists: %d\n",
nds->report_partition_dists);
+ nout(nss, "report_partition_obliq: %d\n",
nds->report_partition_obliq);
+ nout(nss, "report_overlap_reg_names: %d\n",
nds->report_overlap_reg_names);
+ nout(nss, "report_overlap_reg_ids: %d\n",
nds->report_overlap_reg_ids);
+ nout(nss, "report_overlap_dists: %d\n",
nds->report_overlap_dists);
+ nout(nss, "report_overlap_obliq: %d\n",
nds->report_overlap_obliq);
+ nout(nss, "report_gap_dists: %d\n",
nds->report_gap_dists);
+ nout(nss, "dist_delta_tol: %g\n", nds->dist_delta_tol);
+ nout(nss, "obliq_delta_tol: %g\n",
nds->obliq_delta_tol);
+ nout(nss, "los_delta_tol: %g\n", nds->los_delta_tol);
+ nout(nss, "scaled_los_delta_tol: %g\n",
nds->scaled_los_delta_tol);
return 0;
}
if (ac == 1) {
//print specific setting
- if (BU_STR_EQUAL(argv[0], "report_partitions")) nout(nss,
"%d\n", nss->i->diff_settings->report_partitions);
- if (BU_STR_EQUAL(argv[0], "report_misses")) nout(nss,
"%d\n", nss->i->diff_settings->report_misses);
- if (BU_STR_EQUAL(argv[0], "report_gaps")) nout(nss,
"%d\n", nss->i->diff_settings->report_gaps);
- if (BU_STR_EQUAL(argv[0], "report_overlaps")) nout(nss,
"%d\n", nss->i->diff_settings->report_overlaps);
- if (BU_STR_EQUAL(argv[0], "report_partition_reg_ids")) nout(nss,
"%d\n", nss->i->diff_settings->report_partition_reg_ids);
- if (BU_STR_EQUAL(argv[0], "report_partition_reg_names")) nout(nss,
"%d\n", nss->i->diff_settings->report_partition_reg_names);
- if (BU_STR_EQUAL(argv[0], "report_partition_path_names")) nout(nss,
"%d\n", nss->i->diff_settings->report_partition_path_names);
- if (BU_STR_EQUAL(argv[0], "report_partition_dists")) nout(nss,
"%d\n", nss->i->diff_settings->report_partition_dists);
- if (BU_STR_EQUAL(argv[0], "report_partition_obliq")) nout(nss,
"%d\n", nss->i->diff_settings->report_partition_obliq);
- if (BU_STR_EQUAL(argv[0], "report_overlap_reg_names")) nout(nss,
"%d\n", nss->i->diff_settings->report_overlap_reg_names);
- if (BU_STR_EQUAL(argv[0], "report_overlap_reg_ids")) nout(nss,
"%d\n", nss->i->diff_settings->report_overlap_reg_ids);
- if (BU_STR_EQUAL(argv[0], "report_overlap_dists")) nout(nss,
"%d\n", nss->i->diff_settings->report_overlap_dists);
- if (BU_STR_EQUAL(argv[0], "report_overlap_obliq")) nout(nss,
"%d\n", nss->i->diff_settings->report_overlap_obliq);
- if (BU_STR_EQUAL(argv[0], "report_gap_dists")) nout(nss,
"%d\n", nss->i->diff_settings->report_gap_dists);
- if (BU_STR_EQUAL(argv[0], "dist_delta_tol")) nout(nss,
"%g\n", nss->i->diff_settings->dist_delta_tol);
- if (BU_STR_EQUAL(argv[0], "obliq_delta_tol")) nout(nss,
"%g\n", nss->i->diff_settings->obliq_delta_tol);
- if (BU_STR_EQUAL(argv[0], "los_delta_tol")) nout(nss,
"%g\n", nss->i->diff_settings->los_delta_tol);
- if (BU_STR_EQUAL(argv[0], "scaled_los_delta_tol")) nout(nss,
"%g\n", nss->i->diff_settings->scaled_los_delta_tol);
+ if (BU_STR_EQUAL(argv[0], "report_partitions")) nout(nss,
"%d\n", nds->report_partitions);
+ if (BU_STR_EQUAL(argv[0], "report_misses")) nout(nss,
"%d\n", nds->report_misses);
+ if (BU_STR_EQUAL(argv[0], "report_gaps")) nout(nss,
"%d\n", nds->report_gaps);
+ if (BU_STR_EQUAL(argv[0], "report_overlaps")) nout(nss,
"%d\n", nds->report_overlaps);
+ if (BU_STR_EQUAL(argv[0], "report_partition_reg_ids")) nout(nss,
"%d\n", nds->report_partition_reg_ids);
+ if (BU_STR_EQUAL(argv[0], "report_partition_reg_names")) nout(nss,
"%d\n", nds->report_partition_reg_names);
+ if (BU_STR_EQUAL(argv[0], "report_partition_path_names")) nout(nss,
"%d\n", nds->report_partition_path_names);
+ if (BU_STR_EQUAL(argv[0], "report_partition_dists")) nout(nss,
"%d\n", nds->report_partition_dists);
+ if (BU_STR_EQUAL(argv[0], "report_partition_obliq")) nout(nss,
"%d\n", nds->report_partition_obliq);
+ if (BU_STR_EQUAL(argv[0], "report_overlap_reg_names")) nout(nss,
"%d\n", nds->report_overlap_reg_names);
+ if (BU_STR_EQUAL(argv[0], "report_overlap_reg_ids")) nout(nss,
"%d\n", nds->report_overlap_reg_ids);
+ if (BU_STR_EQUAL(argv[0], "report_overlap_dists")) nout(nss,
"%d\n", nds->report_overlap_dists);
+ if (BU_STR_EQUAL(argv[0], "report_overlap_obliq")) nout(nss,
"%d\n", nds->report_overlap_obliq);
+ if (BU_STR_EQUAL(argv[0], "report_gap_dists")) nout(nss,
"%d\n", nds->report_gap_dists);
+ if (BU_STR_EQUAL(argv[0], "dist_delta_tol")) nout(nss,
"%g\n", nds->dist_delta_tol);
+ if (BU_STR_EQUAL(argv[0], "obliq_delta_tol")) nout(nss,
"%g\n", nds->obliq_delta_tol);
+ if (BU_STR_EQUAL(argv[0], "los_delta_tol")) nout(nss,
"%g\n", nds->los_delta_tol);
+ if (BU_STR_EQUAL(argv[0], "scaled_los_delta_tol")) nout(nss,
"%g\n", nds->scaled_los_delta_tol);
return 0;
}
if (ac == 2) {
//set setting
struct bu_vls opt_msg = BU_VLS_INIT_ZERO;
- int *setting_int = NULL;
+ bool *setting_bool = NULL;
fastf_t *setting_fastf_t = NULL;
- if (BU_STR_EQUAL(argv[0], "report_partitions"))
setting_int = &(nss->i->diff_settings->report_partitions);
- if (BU_STR_EQUAL(argv[0], "report_misses"))
setting_int = &(nss->i->diff_settings->report_misses);
- if (BU_STR_EQUAL(argv[0], "report_gaps"))
setting_int = &(nss->i->diff_settings->report_gaps);
- if (BU_STR_EQUAL(argv[0], "report_overlaps"))
setting_int = &(nss->i->diff_settings->report_overlaps);
- if (BU_STR_EQUAL(argv[0], "report_partition_reg_ids"))
setting_int = &(nss->i->diff_settings->report_partition_reg_ids);
- if (BU_STR_EQUAL(argv[0], "report_partition_reg_names"))
setting_int = &(nss->i->diff_settings->report_partition_reg_names);
- if (BU_STR_EQUAL(argv[0], "report_partition_path_names"))
setting_int = &(nss->i->diff_settings->report_partition_path_names);
- if (BU_STR_EQUAL(argv[0], "report_partition_dists"))
setting_int = &(nss->i->diff_settings->report_partition_dists);
- if (BU_STR_EQUAL(argv[0], "report_partition_obliq"))
setting_int = &(nss->i->diff_settings->report_partition_obliq);
- if (BU_STR_EQUAL(argv[0], "report_overlap_reg_names"))
setting_int = &(nss->i->diff_settings->report_overlap_reg_names);
- if (BU_STR_EQUAL(argv[0], "report_overlap_reg_ids"))
setting_int = &(nss->i->diff_settings->report_overlap_reg_ids);
- if (BU_STR_EQUAL(argv[0], "report_overlap_dists"))
setting_int = &(nss->i->diff_settings->report_overlap_dists);
- if (BU_STR_EQUAL(argv[0], "report_overlap_obliq"))
setting_int = &(nss->i->diff_settings->report_overlap_obliq);
- if (BU_STR_EQUAL(argv[0], "report_gap_dists"))
setting_int = &(nss->i->diff_settings->report_gap_dists);
- if (BU_STR_EQUAL(argv[0], "dist_delta_tol"))
setting_fastf_t = &(nss->i->diff_settings->dist_delta_tol);
- if (BU_STR_EQUAL(argv[0], "obliq_delta_tol"))
setting_fastf_t = &(nss->i->diff_settings->obliq_delta_tol);
- if (BU_STR_EQUAL(argv[0], "los_delta_tol"))
setting_fastf_t = &(nss->i->diff_settings->los_delta_tol);
- if (BU_STR_EQUAL(argv[0], "scaled_los_delta_tol"))
setting_fastf_t = &(nss->i->diff_settings->scaled_los_delta_tol);
+ if (BU_STR_EQUAL(argv[0], "report_partitions"))
setting_bool = &(nds->report_partitions);
+ if (BU_STR_EQUAL(argv[0], "report_misses"))
setting_bool = &(nds->report_misses);
+ if (BU_STR_EQUAL(argv[0], "report_gaps"))
setting_bool = &(nds->report_gaps);
+ if (BU_STR_EQUAL(argv[0], "report_overlaps"))
setting_bool = &(nds->report_overlaps);
+ if (BU_STR_EQUAL(argv[0], "report_partition_reg_ids"))
setting_bool = &(nds->report_partition_reg_ids);
+ if (BU_STR_EQUAL(argv[0], "report_partition_reg_names"))
setting_bool = &(nds->report_partition_reg_names);
+ if (BU_STR_EQUAL(argv[0], "report_partition_path_names"))
setting_bool = &(nds->report_partition_path_names);
+ if (BU_STR_EQUAL(argv[0], "report_partition_dists"))
setting_bool = &(nds->report_partition_dists);
+ if (BU_STR_EQUAL(argv[0], "report_partition_obliq"))
setting_bool = &(nds->report_partition_obliq);
+ if (BU_STR_EQUAL(argv[0], "report_overlap_reg_names"))
setting_bool = &(nds->report_overlap_reg_names);
+ if (BU_STR_EQUAL(argv[0], "report_overlap_reg_ids"))
setting_bool = &(nds->report_overlap_reg_ids);
+ if (BU_STR_EQUAL(argv[0], "report_overlap_dists"))
setting_bool = &(nds->report_overlap_dists);
+ if (BU_STR_EQUAL(argv[0], "report_overlap_obliq"))
setting_bool = &(nds->report_overlap_obliq);
+ if (BU_STR_EQUAL(argv[0], "report_gap_dists"))
setting_bool = &(nds->report_gap_dists);
+ if (BU_STR_EQUAL(argv[0], "dist_delta_tol"))
setting_fastf_t = &(nds->dist_delta_tol);
+ if (BU_STR_EQUAL(argv[0], "obliq_delta_tol"))
setting_fastf_t = &(nds->obliq_delta_tol);
+ if (BU_STR_EQUAL(argv[0], "los_delta_tol"))
setting_fastf_t = &(nds->los_delta_tol);
+ if (BU_STR_EQUAL(argv[0], "scaled_los_delta_tol"))
setting_fastf_t = &(nds->scaled_los_delta_tol);
- if (setting_int) {
- if (bu_opt_int(&opt_msg, 1, (const char **)&argv[1], (void
*)setting_int) == -1) {
+ if (setting_bool) {
+ if (bu_opt_bool(&opt_msg, 1, (const char **)&argv[1], (void
*)setting_bool) == -1) {
nerr(nss, "Error: bu_opt value read failure: %s\n",
bu_vls_addr(&opt_msg));
bu_vls_free(&opt_msg);
return -1;
Modified: brlcad/trunk/src/libanalyze/nirt/nirt.cpp
===================================================================
--- brlcad/trunk/src/libanalyze/nirt/nirt.cpp 2020-03-09 14:47:01 UTC (rev
75001)
+++ brlcad/trunk/src/libanalyze/nirt/nirt.cpp 2020-03-09 15:57:59 UTC (rev
75002)
@@ -1197,8 +1197,8 @@
}
vals->seg = s;
- if (!nss->i->diff_run) _nirt_report(nss, 'r', vals);
- if (!nss->i->diff_run) _nirt_report(nss, 'h', vals);
+ _nirt_report(nss, 'r', vals);
+ _nirt_report(nss, 'h', vals);
if (nss->i->overlap_claims == NIRT_OVLP_REBUILD_FASTGEN) {
rt_rebuild_overlaps(part_head, ap, 1);
@@ -1242,7 +1242,7 @@
if (s->gap_los > 0) {
s->type = NIRT_GAP_SEG;
- if (!nss->i->diff_run) _nirt_report(nss, 'g', vals);
+ _nirt_report(nss, 'g', vals);
_nirt_diff_add_seg(nss, s);
/* vlist segment for gap */
vhead = bn_vlblock_find(nss->i->segs,
nss->i->void_color->buc_rgb[RED], nss->i->void_color->buc_rgb[GRN],
nss->i->void_color->buc_rgb[BLU]);
@@ -1305,7 +1305,7 @@
}
}
- if (!nss->i->diff_run) _nirt_report(nss, 'p', vals);
+ _nirt_report(nss, 'p', vals);
/* vlist segment for hit */
if (ev_odd % 2) {
@@ -1350,7 +1350,7 @@
s->ov_d_out = vals->d_orig - ovp->out_dist; // TODO looks sketchy
in NIRT - did they really mean target(D) ?? -> (VTI_XORIG + 3 -> VTI_H)
s->ov_los = s->ov_d_in - s->ov_d_out;
- if (!nss->i->diff_run) _nirt_report(nss, 'o', vals);
+ _nirt_report(nss, 'o', vals);
/* vlist segment for overlap */
if (nss->i->plot_overlaps) {
@@ -1369,7 +1369,7 @@
}
- if (!nss->i->diff_run) _nirt_report(nss, 'f', vals);
+ _nirt_report(nss, 'f', vals);
if (vals->ovlp_list.forw != &(vals->ovlp_list)) {
nerr(nss, "Previously unreported overlaps. Shouldn't happen\n");
@@ -1390,8 +1390,8 @@
_nirt_if_miss(struct application *ap)
{
struct nirt_state *nss = (struct nirt_state *)ap->a_uptr;
- if (!nss->i->diff_run) _nirt_report(nss, 'r', nss->i->vals);
- if (!nss->i->diff_run) _nirt_report(nss, 'm', nss->i->vals);
+ _nirt_report(nss, 'r', nss->i->vals);
+ _nirt_report(nss, 'm', nss->i->vals);
// TODO - handle miss diffing...
@@ -2871,7 +2871,6 @@
bu_vls_free(ns->i->err);
bu_vls_free(ns->i->msg);
bu_vls_free(ns->i->out);
- bu_vls_free(ns->i->diff_file);
bn_vlist_cleanup(&(ns->i->s_vlist));
bn_vlblock_free(ns->i->segs);
@@ -2880,7 +2879,6 @@
db_close(ns->i->dbip);
- BU_PUT(ns->i->diff_settings, struct nirt_diff_settings);
BU_PUT(ns->i->vals, struct nirt_output_record);
BU_PUT(ns->i->res, struct resource);
@@ -2888,7 +2886,6 @@
BU_PUT(ns->i->err, struct bu_vls);
BU_PUT(ns->i->msg, struct bu_vls);
BU_PUT(ns->i->out, struct bu_vls);
- BU_PUT(ns->i->diff_file, struct bu_vls);
BU_PUT(ns->i->ap, struct application);
BU_PUT(ns->i->hit_odd_color, struct bu_color);
BU_PUT(ns->i->hit_even_color, struct bu_color);
Modified: brlcad/trunk/src/libanalyze/nirt/nirt.h
===================================================================
--- brlcad/trunk/src/libanalyze/nirt/nirt.h 2020-03-09 14:47:01 UTC (rev
75001)
+++ brlcad/trunk/src/libanalyze/nirt/nirt.h 2020-03-09 15:57:59 UTC (rev
75002)
@@ -154,7 +154,7 @@
};
-struct nirt_diff;
+struct nirt_diff_state;
struct nirt_state_impl {
/* Output options */
@@ -198,11 +198,7 @@
std::vector<std::string> active_paths; // active paths for raytracer
struct nirt_output_record *vals;
struct bu_vls *diff_file;
- struct nirt_diff *cdiff;
- std::vector<struct nirt_diff *> diffs;
- struct nirt_diff_settings *diff_settings;
- int diff_run;
- int diff_ready;
+ struct nirt_diff_state *diff_state;
/* state alteration flags */
bool b_state; // updated for any state change
This was sent by the SourceForge.net collaborative development platform, the
world's largest Open Source development site.
_______________________________________________
BRL-CAD Source Commits mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/brlcad-commits
