0

Here is the code that I have been given for an assignment. The modification that I need to make is to allow the program to read 10 sample points and determine which are contained in the plume boundary. I have included the modification that I think is appropriate for the requirement but I just want to check if this looks right. Also any suggestions on how to better accomplish the requirement would be greatly appreciated.

Don't mind the k variable and cout statement in the function
void Boundary_map::read_boundary_pts(). It is just a test to make sure the input file is being read.

// UNDERGROUND POLLUTION PLUME BOUNDARIES

#include <iostream>
#include <cmath>
#include <fstream>
using namespace std;

const int LARGE_NUM = 1.0E10;

struct Point
{
     public:
          double x, y;
};

struct Line_seg
{
     public:
          Point endpt1, endpt2;
          double slope, intercept;
};

class Boundary_map
{
     private:
		 enum{NUM_MAP_PTS = 10};
          Point boundary_pts [NUM_MAP_PTS + 1];
     public:
          Boundary_map();
          void read_boundary_pts();
          void map_wrap_around();
          Point* get_boundary_pts();
          int get_num_boundary_pts();
};

class Probe
{
     private:
          Point sample_pt, endpt1, endpt2;
          int num_crosses;
          Point probe_line_intersect(Line_seg);
          int probe_line_seg_intersect(Point, Line_seg);
     public:
          Probe();
          void read_sample_pt();
          void check_map_boundary(Point*, int);
};

Boundary_map::Boundary_map()
{
     int i;
     for (i = 0; i <NUM_MAP_PTS + 1; i++)
     {
          boundary_pts[i].x = 0;
          boundary_pts[i].y = 0;
     }
}

void Boundary_map::read_boundary_pts()
{
     int i,k;
	 ifstream infile ("C:\\BNDARY.TXT");
	 k = infile.eof();
	 cout<<k<<endl;
     for (i = 0; i < NUM_MAP_PTS + 1; i++)
     {
          infile >> boundary_pts[i].x;
          infile >> boundary_pts[i].y;
     }
	 k = infile.eof();
	 cout<<k<<endl;
}

void Boundary_map::map_wrap_around()
{
     boundary_pts[NUM_MAP_PTS] = boundary_pts[0];
}

Point* Boundary_map::get_boundary_pts()
{
	return(boundary_pts);
}

int Boundary_map::get_num_boundary_pts()
{
     return(NUM_MAP_PTS + 1);
}

Probe::Probe()
{
     sample_pt.x = 0;
     sample_pt.y = 0;
     endpt1.x = 0;
     endpt1.y = 0;
     endpt2.x = LARGE_NUM;
     endpt2.y = 0;
     num_crosses = 0;
}

void Probe::read_sample_pt()
{
     cout << "Enter the x and Y coordinates of the sample point" << endl;
     cin >> sample_pt.x >> sample_pt.y;
     endpt1 = sample_pt;
     endpt2.y = sample_pt.y;
}

Point Probe::probe_line_intersect(Line_seg map_line_seg)
{
     Point intersect_pt;
     double probe_slope, probe_intercept;
     if (fabs (map_line_seg.endpt2.x - map_line_seg.endpt1.x) < 1.0E-20)
     {
          intersect_pt.x = map_line_seg.endpt1.x;
          intersect_pt.y = endpt1.y;
     }

     else
     {
          map_line_seg.slope = (map_line_seg.endpt2.y
             - map_line_seg.endpt1.y) / (map_line_seg.endpt2.x
             - map_line_seg.endpt2.x);

          map_line_seg.intercept = map_line_seg.endpt2.y
             - map_line_seg.slope * map_line_seg.endpt2.x;

          probe_slope = 0.0;
          probe_intercept  = sample_pt.y;

          if (fabs (map_line_seg.slope) < 1.0E-20)
          {
               intersect_pt.x = LARGE_NUM;
               intersect_pt.y = LARGE_NUM;
          }

          intersect_pt.x = (probe_intercept - map_line_seg.intercept) /
             (map_line_seg.slope - probe_slope);

          intersect_pt.y = map_line_seg.slope * intersect_pt.x
             + map_line_seg.intercept;
     }

return(intersect_pt);
}

int Probe::probe_line_seg_intersect (Point intersect_pt, Line_seg seg2)
{
     Line_seg seg1;
     double x_low_1, x_high_1, x_low_2, x_high_2;
     double y_low_1, y_high_1, y_low_2, y_high_2;

     seg1.endpt1 = endpt1;
     seg1.endpt2 = endpt2;

     x_low_1 = (seg1.endpt1.x < seg1.endpt2.x) ?
        seg1.endpt1.x : seg1.endpt2.x;
     x_high_1 = (seg1.endpt1.x > seg1.endpt2.x) ?
        seg1.endpt1.x : seg1.endpt2.x;
     x_low_2 = (seg2.endpt1.x < seg2.endpt2.x) ?
        seg2.endpt1.x : seg2.endpt2.x;
     x_high_2 = (seg2.endpt1.x > seg2.endpt2.x) ?
        seg2.endpt1.x : seg2.endpt2.x;
     y_low_1 = (seg1.endpt1.y < seg1.endpt2.y) ?
        seg1.endpt1.y : seg1.endpt2.y;
     y_high_1 = (seg1.endpt1.y > seg1.endpt2.y) ?
        seg1.endpt1.y : seg1.endpt2.y;
     y_low_2 = (seg2.endpt1.y < seg2.endpt2.y) ?
        seg2.endpt1.y : seg2.endpt2.y;
     y_high_2 = (seg2.endpt1.y > seg2.endpt2.y) ?
        seg2.endpt1.y : seg2.endpt2.y;

     if ((x_low_1 <= intersect_pt.x && 
		 intersect_pt.x <= x_high_1) && 
		 (x_low_2 <= intersect_pt.x && 
		 intersect_pt.x <= x_high_2) && 
		 (y_low_1 <= intersect_pt.y && 
		 intersect_pt.y <= y_high_1) &&
         (y_low_2 <= intersect_pt.y && 
		 intersect_pt.y <= y_high_2))

          {
			  return(1);
          }

     else

          {
			  return(0);
          }
}

void Probe::check_map_boundary (Point* bnd_pt, int num_pts)
{
     int i, does_cross, even_odd;
     Point intersect_pt;
     Line_seg map_line_seg;
     for (i = 0; i < num_pts - 1; i++)
     {
          map_line_seg.endpt1 = bnd_pt[i];
          map_line_seg.endpt2 = bnd_pt[i + 1];
          intersect_pt = probe_line_intersect
             (map_line_seg);
          does_cross = probe_line_seg_intersect
             (intersect_pt, map_line_seg);
          num_crosses += does_cross;
      }

     even_odd = num_crosses % 2;
     if (even_odd == 0) cout << "The sample point is outside the plume." << endl;
     if (even_odd == 1) cout << "The sample point is inside the plume." << endl;
}

int main()
{
     Boundary_map plume_map;
     Probe probe_from_water_sample;

     plume_map.read_boundary_pts();
     plume_map.map_wrap_around();

     probe_from_water_sample.read_sample_pt();

     probe_from_water_sample.check_map_boundary
        (plume_map.get_boundary_pts(),
        plume_map.get_num_boundary_pts());
	 system("pause");
}
1
Contributor
1
Reply
2
Views
7 Years
Discussion Span
Last Post by mdeveau
0

Here is my modification. I forgot to add it to my original post. Basically what I did is create a for loop in the main function that would run the entire program ten times allowing the user to enter in ten seperate data points. I think that this will work but what I would like to do is create a way for the user to enter ten data points into an array and then have the program access the array so that it becomes a much smoother functioning program. Any suggestions?

int main()
{
     int i;
     
     for (i = 0; i < 10; i++)
     {
     Boundary_map plume_map;
     Probe probe_from_water_sample;

     plume_map.read_boundary_pts();
     plume_map.map_wrap_around();

     probe_from_water_sample.read_sample_pt();

     probe_from_water_sample.check_map_boundary
        (plume_map.get_boundary_pts(),
        plume_map.get_num_boundary_pts());
     }	 
     system("pause");
}
This topic has been dead for over six months. Start a new discussion instead.
Have something to contribute to this discussion? Please be thoughtful, detailed and courteous, and be sure to adhere to our posting rules.