void WitnessSet::write_dehomogenized_coordinates(boost::filesystem::path filename) const
{
vec_mp result; init_vec_mp(result,1);
FILE *OUT = safe_fopen_write(filename.c_str()); // open the output file.
fprintf(OUT,"%zu\n\n",num_points()); // print the header line
for (unsigned int ii=0; ii<num_points(); ++ii) {
if (this->num_synth_vars()>0) {
dehomogenize(&result,point(ii), num_natty_vars_);
}
else{
dehomogenize(&result,point(ii));
}
for (int jj=0; jj<num_natty_vars_-1; jj++) {
print_mp(OUT, 0, &result->coord[jj]);
fprintf(OUT, "\n");
}
fprintf(OUT,"\n");
}
fclose(OUT);
clear_vec_mp(result);
return;
}
void WitnessSet::print_to_screen() const
{
vec_mp dehom; init_vec_mp(dehom,1); dehom->size = 1;
std::stringstream varname;
std::cout << "witness set has " << num_vars_ << " total variables, " << num_natty_vars_ << " natural variables." << std::endl;
std::cout << "dim " << dim_ << ", comp " << comp_num_ << std::endl;
std::cout << "input file name " << input_filename_ << std::endl;
printf("******\n%zu points\n******\n",num_points());
std::cout << color::green();
for (unsigned ii=0; ii<num_points(); ii++) {
dehomogenize(&dehom, point(ii), num_natty_vars_);
varname << "point_" << ii;
print_point_to_screen_matlab(dehom,varname.str());
varname.str("");
}
std::cout << color::console_default();
std::cout << color::blue();
printf("******\n%zu linears\n******\n",num_linears());
for (unsigned ii=0; ii<num_linears(); ii++) {
varname << "linear_" << ii;
print_point_to_screen_matlab(linear(ii),varname.str());
varname.str("");
}
std::cout << color::console_default();
std::cout << color::cyan();
printf("******\n%zu patches\n******\n",num_patches());
for (unsigned ii=0; ii<num_patches(); ii++) {
varname << "patch_" << ii;
print_point_to_screen_matlab(patch(ii),varname.str());
varname.str("");
}
std::cout << color::console_default();
std::cout << "variable names:\n";
for (unsigned ii=0; ii< num_var_names(); ii++) {
std::cout << name(ii) << "\n";
}
printf("\n\n");
clear_vec_mp(dehom);
}
void WitnessSet::sort_for_real(tracker_config_t * T)
{
int *real_indicator = new int[num_points()];
int counter = 0;
vec_mp result; init_vec_mp(result,num_natty_vars_-1);
result->size = num_natty_vars_-1;
for (unsigned int ii=0; ii<num_points(); ii++) {
vec_mp & curr_point = point(ii);
for (int jj=1; jj<num_natty_vars_; jj++) {
div_mp(&result->coord[jj-1], &curr_point->coord[jj], &curr_point->coord[0]);
}
real_indicator[ii] = checkForReal_mp(result, T->real_threshold);
if (real_indicator[ii]==1) {
counter++;
}
}
vec_mp *tempvec = (vec_mp *)br_malloc(counter * sizeof(vec_mp));
counter = 0; // reset
for (unsigned int ii=0; ii<num_points(); ii++) {
vec_mp & curr_point = point(ii);
if (real_indicator[ii]==1) {
init_vec_mp2(tempvec[counter],this->num_vars_,1024); tempvec[counter]->size = this->num_vars_;
vec_cp_mp(tempvec[counter],curr_point);
counter++;
}
else{
}
}
clear_vec_mp(result);
for (unsigned int ii=0; ii<num_points(); ii++) {
clear_vec_mp(point(ii));
}
free(pts_mp_);
pts_mp_ = tempvec;
num_pts_ = counter;
delete[] real_indicator;
return;
}
static void
init_delete_point(F_line *obj, int type, int x, int y, F_point *p, F_point *q)
{
int n;
switch (type) {
case O_POLYLINE:
cur_l = (F_line *) obj;
/* the search routine will ensure we don't have a box */
n = num_points(cur_l->points);
if (cur_l->type == T_POLYGON) {
if (n <= 4) { /* count first pt twice for closed object */
put_msg("A polygon cannot have less than 3 points");
beep();
return;
}
} else if (n <= 1) {
/* alternative would be to remove the dot altogether */
put_msg("A dot must have at least 1 point");
beep();
return;
}
linepoint_deleting(cur_l, p, q);
break;
case O_SPLINE:
cur_s = (F_spline *) obj;
n = num_points(cur_s->points);
if (closed_spline(cur_s)) {
if (n <= CLOSED_SPLINE_MIN_NUM_POINTS) {
put_msg("A closed spline cannot have less than %d points",
CLOSED_SPLINE_MIN_NUM_POINTS);
beep();
return;
}
} else if (n <= OPEN_SPLINE_MIN_NUM_POINTS) {
put_msg("A spline cannot have less than %d points",
OPEN_SPLINE_MIN_NUM_POINTS);
beep();
return;
}
splinepoint_deleting(cur_s, p, q);
break;
default:
return;
}
}
void WitnessSet::send(ParallelismConfig & mpi_config, int target) const
{
//send all the data to the other party
//
//
// std::vector< std::string > variable_names;
//
// boost::filesystem::path input_filename;
// function input_file;
// // end data members
int *buffer = (int *) br_malloc(8*sizeof(int));
buffer[0] = dimension();
buffer[1] = component_number();
buffer[2] = incidence_number();
buffer[3] = num_variables();
buffer[4] = num_natural_variables();
buffer[5] = num_points();
buffer[6] = num_linears();
buffer[7] = num_patches();
MPI_Send(buffer, 8, MPI_INT, WITNESS_SET, target, mpi_config.comm());
free(buffer);
for (unsigned int ii=0; ii<num_linears(); ii++) {
send_vec_mp( linear(ii),target);
}
for (unsigned int ii=0; ii<num_patches(); ii++) {
send_vec_mp( patch(ii),target);
}
for (unsigned int ii=0; ii<num_points(); ii++) {
send_vec_mp( point(ii) ,target);
}
char * namebuffer = (char *) br_malloc(1024*sizeof(char));
free(namebuffer);
return;
}
void WitnessSet::write_homogeneous_coordinates(boost::filesystem::path filename) const
{
FILE *OUT = safe_fopen_write(filename.c_str()); // open the output file
fprintf(OUT,"%zu\n\n",num_points()); // print the header line
for (unsigned int ii=0; ii<num_points(); ++ii) {
vec_mp &curr_point = point(ii);
for ( int jj=0; jj< curr_point->size; jj++) {
print_mp(OUT,0,&( curr_point->coord[jj]));
fprintf(OUT,"\n");
}
fprintf(OUT,"\n");
}
fclose(OUT); // close the output file
return;
}
void WitnessSet::only_first_vars(int num_vars)
{
vec_mp tempvec; init_vec_mp2(tempvec, num_vars, 1024);
tempvec->size = num_vars;
for (unsigned int ii=0; ii<num_points(); ii++) {
vec_mp & curr_point = point(ii);
for (int jj=0; jj<num_vars; jj++) {
set_mp(&tempvec->coord[jj], &curr_point->coord[jj]);
}
change_size_vec_mp(curr_point, num_vars); curr_point->size = num_vars;
vec_cp_mp(curr_point, tempvec);
}
this->num_vars_ = num_vars;
int patch_size_counter = 0, trim_from_here = 0;
for (unsigned int ii=0; ii<num_patches(); ii++) {
patch_size_counter += patch(ii)->size;
if (patch_size_counter == num_vars)
{
trim_from_here = ii+1;
}
}
if (trim_from_here==0) {
std::cerr << "problem: the sum of the patch sizes never equalled the number of variables to trim to...\nhence, the trimming operation could not complete." << std::endl;
this->print_to_screen();
deliberate_segfault();
}
for (unsigned int ii=trim_from_here; ii<num_patches(); ii++) {
clear_vec_mp(patch(ii));
}
patch_mp_ = (vec_mp *) br_realloc(patch_mp_, trim_from_here* sizeof(vec_mp));
num_patches_ = trim_from_here;
for (unsigned int ii=0; ii<num_linears(); ii++) {
linear(ii)->size = num_vars;
}
clear_vec_mp(tempvec);
return;
}
double area() const
{
double sum = 0.0;
double x(0);
double y(0);
rewind(0);
double xs = x;
double ys = y;
for (unsigned i=0;i<num_points();++i)
{
double x0,y0;
vertex(&x0,&y0);
sum += x * y0 - y * x0;
x = x0;
y = y0;
}
return (sum + x * ys - y * xs) * 0.5;
}
box2d<double> envelope() const
{
box2d<double> result;
double x(0);
double y(0);
rewind(0);
for (unsigned i=0;i<num_points();++i)
{
vertex(&x,&y);
if (i==0)
{
result.init(x,y,x,y);
}
else
{
result.expand_to_include(x,y);
}
}
return result;
}
void WitnessSet::write_dehomogenized_coordinates(boost::filesystem::path filename,std::set<unsigned int> indices) const
{
for (auto ii=indices.begin(); ii!=indices.end(); ++ii) {
if (*ii >= this->num_points()) {
std::cout << "requested to print out-of-range point index " << *ii << " to a dehomogenized file." << std::endl;
std::cout << "[this WitnessSet contains " << num_points() << " points.]" << std::endl;
br_exit(66190);
}
}
vec_mp result; init_vec_mp(result,1);
FILE *OUT = safe_fopen_write(filename.c_str()); // open the output file.
fprintf(OUT,"%lu\n\n",indices.size()); // print the header line
for (auto ii=indices.begin(); ii!=indices.end(); ++ii) {
if (this->num_synth_vars()>0) {
dehomogenize(&result,this->point(*ii), num_natty_vars_);
}
else{
dehomogenize(&result,this->point(*ii));
}
for (int jj=0; jj<num_natty_vars_-1; jj++) {
print_mp(OUT, 0, &result->coord[jj]);
fprintf(OUT, "\n");
}
fprintf(OUT,"\n");
}
fclose(OUT);
clear_vec_mp(result);
return;
}
void
line_spline(F_line *l, int type_value)
{
F_spline *s;
if (num_points(l->points) < CLOSED_SPLINE_MIN_NUM_POINTS) {
put_msg("Not enough points for a spline");
beep();
return;
}
if ((s = create_spline()) == NULL)
return;
s->type = type_value;
if (l->type == T_POLYGON)
s->points = copy_points(l->points->next);
else
s->points = copy_points(l->points);
s->style = l->style;
s->thickness = l->thickness;
s->pen_color = l->pen_color;
s->fill_color = l->fill_color;
s->depth = l->depth;
s->style_val = l->style_val;
s->cap_style = l->cap_style;
s->pen_style = l->pen_style;
s->fill_style = l->fill_style;
s->sfactors = NULL;
s->next = NULL;
if (l->for_arrow) {
s->for_arrow = create_arrow();
s->for_arrow->type = l->for_arrow->type;
s->for_arrow->style = l->for_arrow->style;
s->for_arrow->thickness = l->for_arrow->thickness;
s->for_arrow->wd = l->for_arrow->wd;
s->for_arrow->ht = l->for_arrow->ht;
} else {
s->for_arrow = NULL;
}
if (l->back_arrow) {
s->back_arrow = create_arrow();
s->back_arrow->type = l->back_arrow->type;
s->back_arrow->style = l->back_arrow->style;
s->back_arrow->thickness = l->back_arrow->thickness;
s->back_arrow->wd = l->back_arrow->wd;
s->back_arrow->ht = l->back_arrow->ht;
} else {
s->back_arrow = NULL;
}
/* A spline must have an s parameter for each point */
if (!make_sfactors(s)) {
free_spline(&s);
return;
}
/* Get rid of the line and draw the new spline */
delete_line(l);
/* now put back the new spline */
mask_toggle_splinemarker(s);
list_add_spline(&objects.splines, s);
redisplay_spline(s);
set_action_object(F_CONVERT, O_POLYLINE);
set_latestspline(s);
set_modifiedflag();
}
void WitnessSet::merge(const WitnessSet & W_in, tracker_config_t * T)
{
//error checking first
if ( (num_vars_==0) && (W_in.num_vars_!=0) && (num_points()==0)) {
num_vars_ = W_in.num_vars_;
num_natty_vars_ = W_in.num_natty_vars_;
}
if (W_in.num_natty_vars_ != this->num_natty_vars_) {
std::stringstream ss;
ss << "merging two witness sets with differing numbers of natural variables. "<< W_in.num_natural_variables() <<" merging set, "<< this->num_natural_variables() << " existing\n",
throw std::logic_error(ss.str());
}
//just mindlessly add the linears. up to user to ensure linears get merged correctly. no way to know what they want...
for (unsigned int ii = 0; ii<W_in.num_linears(); ii++) {
WitnessSet::add_linear(W_in.linear(ii));
}
for (unsigned int ii = 0; ii<W_in.num_points(); ii++) {
int is_new = 1;
vec_mp & in_point = W_in.point(ii);
for (unsigned int jj = 0; jj<num_points(); jj++){
vec_mp & curr_point = this->point(jj);
//cache the sizes
int in_size = in_point->size;
int curr_size = curr_point->size;
in_point->size = this->num_natural_variables();
curr_point->size = this->num_natural_variables();
if (isSamePoint_homogeneous_input(curr_point, in_point, T->final_tol_times_mult)) {
is_new = 0;
in_point->size = in_size;
curr_point->size = curr_size;
break;
}
// restore the sizes
in_point->size = in_size;
curr_point->size = curr_size;
}
if (is_new==1)
WitnessSet::add_point( (in_point) );
}
for (unsigned int ii = 0; ii<W_in.num_patches(); ii++) {
int is_new = 1;
for (unsigned int jj = 0; jj<this->num_patches(); jj++){
if ( this->patch(jj)->size == W_in.patch(ii)->size) {
if (isSamePoint_inhomogeneous_input(patch(jj), W_in.patch(ii), T->final_tol_times_mult)) {
is_new = 0;
break;
}
}
}
if (is_new==1)
WitnessSet::add_patch(W_in.patch(ii));
}
return;
}//re: merge_witness_sets
void WitnessSet::sort_for_inside_sphere(comp_mp radius, vec_mp center)
{
int num_good_pts = 0;
std::vector<int> is_ok;
vec_mp temp_vec; init_vec_mp(temp_vec,0);
comp_mp temp; init_mp(temp);
for (unsigned int ii = 0; ii<num_points(); ++ii) {
dehomogenize(&temp_vec, point(ii),num_natty_vars_);
temp_vec->size = center->size;
norm_of_difference(temp->r, temp_vec, center);
if ( mpf_cmp(temp->r, radius->r) < 0 ){
is_ok.push_back(1);
num_good_pts++;
}
else
{
is_ok.push_back(0);
}
}
vec_mp *transferme = (vec_mp *)br_malloc(num_good_pts*sizeof(vec_mp));
int counter = 0;
for (unsigned int ii=0; ii<num_points(); ++ii) {
if (is_ok[ii]==1) {
init_vec_mp2(transferme[counter],0,1024); transferme[counter]->size = 0;
vec_cp_mp(transferme[counter], point(ii));
counter++;
}
}
if (counter!= num_good_pts) {
printf("counter mismatch\n");
br_exit(271);
}
for (unsigned int ii=0; ii<num_points(); ii++) {
clear_vec_mp(point(ii));
}
free(pts_mp_);
num_pts_ = num_good_pts;
pts_mp_ = transferme;
clear_vec_mp(temp_vec);
clear_mp(temp);
return;
}
// T is necessary for the tolerances.
void WitnessSet::sort_for_unique(tracker_config_t * T)
{
if (num_vars_==0) {
throw std::logic_error("sorting witness set with 0 variables for uniqueness");
}
int curr_uniqueness;
int num_good_pts = 0;
std::vector<int> is_unique;
for (unsigned int ii = 0; ii<num_points(); ++ii) {
vec_mp &curr_point = point(ii);
curr_uniqueness = 1;
int prev_size_1 = curr_point->size; curr_point->size = num_natty_vars_; // cache and change to natural number
for (unsigned int jj=ii+1; jj<num_points(); ++jj) {
vec_mp & inner_point = point(jj);
int prev_size_2 = inner_point->size; inner_point->size = num_natty_vars_; // cache and change to natural number
if ( isSamePoint_homogeneous_input(curr_point,inner_point,T->final_tol_times_mult) ){
curr_uniqueness = 0;
}
inner_point->size = prev_size_2; // restore
}
curr_point->size = prev_size_1; // restore
if (curr_uniqueness==1) {
is_unique.push_back(1);
num_good_pts++;
}
else {
is_unique.push_back(0);
}
}
vec_mp *transferme = (vec_mp *)br_malloc(num_good_pts*sizeof(vec_mp));
int counter = 0;
for (unsigned int ii=0; ii<num_points(); ++ii) {
if (is_unique[ii]==1) {
init_vec_mp2(transferme[counter],num_vars_,1024); transferme[counter]->size = num_vars_;
vec_cp_mp(transferme[counter], point(ii));
counter++;
}
}
if (counter!= num_good_pts) {
std::logic_error("counter mismatch");
}
if (num_points()>0) {
for (unsigned int ii=0; ii<num_points(); ii++) {
clear_vec_mp(point(ii));
}
free(pts_mp_);
}
num_pts_ = num_good_pts;
pts_mp_ = transferme;
return;
}
void WitnessSet::print_to_file(boost::filesystem::path filename) const
{
// print back into the same format we parse from.
FILE *OUT = safe_fopen_write(filename);
fprintf(OUT, "%zu %d %d\n\n", num_points(), dim_, comp_num_);
for (unsigned int ii=0; ii < num_points(); ii++) {
vec_mp & curr_point = point(ii);
//print the witness points into file
for (int jj=0; jj < curr_point->size; ++jj) {
mpf_out_str(OUT,10,0,curr_point->coord[jj].r); // 10 is the base
fprintf(OUT," ");
mpf_out_str(OUT,10,0,curr_point->coord[jj].i);
fprintf(OUT,"\n");
}
fprintf(OUT,"\n");
}
fprintf(OUT,"\n");
fprintf(OUT, "%zu %d\n", num_linears(), num_vars_);
for (unsigned int ii=0; ii < num_linears(); ii++) {
for (int jj=0; jj < linear(ii)->size; jj++) {
mpf_out_str(OUT,10,0,linear(ii)->coord[jj].r); // 10 is the base
fprintf(OUT," ");
mpf_out_str(OUT,10,0,linear(ii)->coord[jj].i);
fprintf(OUT,"\n");
}
fprintf(OUT,"\n");
}
fprintf(OUT,"\n");
fprintf(OUT, "%zu %d\n", num_patches(), num_vars_);
for (unsigned int ii=0; ii < num_patches(); ii++) {
vec_mp & curr_patch = patch(ii);
//read the patch into memory
for (int jj=0; jj < curr_patch->size; jj++) {
mpf_out_str(OUT,10,0,curr_patch->coord[jj].r); // 10 is the base
fprintf(OUT," ");
mpf_out_str(OUT,10,0,curr_patch->coord[jj].i);
fprintf(OUT,"\n");
}
fprintf(OUT,"\n");
}
fprintf(OUT,"\n");
fclose(OUT);
return;
}
