doxygen.cpp.bak

#include <iostream>
#include <vector>
#include <sstream>
#include <fstream>
#include <string>

using namespace std;


class vertex{
public:
	float x;
	float y;
	float z;

	//std::vector<vertex> v;

	vertex(float _x, float _y, float _z){
		x=_x; y=_y; z=_z;
	}

};

class edge{
public:
	float x1;
	float y1;
	float z1;
	float x2;
	float y2;
	float z2;	

 	//std::vector<edge> E;
	
 	edge(float _x1, float _y1, float _z1,float _x2, float _y2, float _z2){
 		x1=_x1; y1=_y1; z1=_z1;x2=_x2; y2=_y2; z2=_z2;	
 	}

};

class twodtothreed{
public:
	std::vector<vertex> fv;
	std::vector<vertex> tv;
	std::vector<vertex> sv;

	std::vector<edge> fe;
	std::vector<edge> te;
	std::vector<edge> se;
	
	std::vector<vertex> pt;
	std::vector<edge> ln;

	void crete3D(){
		for (int i = 0; i < fv.size(); ++i)
		{
			for (int j = 0; j < tv.size(); ++j)
			{
				for (int k = 0; k < sv.size(); ++k)
				{
					if (fv[i].x == tv[j].x)
					{
						if (tv[j].z == sv[k].z)
						{
							if (sv[k].y == fv[i].y)
							{
								pt.push_back(vertex(fv[i].x, sv[k].y, tv[j].z ));
							}
						}
					}
				}
			}
		}

		for (int s = 0; s < pt.size(); ++s)
		{
			for (int t = 0; t < pt.size(); ++t)
			{
				for (int a = 0; a < fe.size(); ++a)
				{
					if (((pt[s].x == fe[a].x1) && (pt[t].x == fe[a].x2) && (pt[s].y == fe[a].y1) && (pt[t].y == fe[a].y2))
						or ((pt[t].x == fe[a].x1) && (pt[s].x == fe[a].x2) && (pt[t].y == fe[a].y1) && (pt[s].y == fe[a].y2) ))
					{
						for (int b = 0; b < te.size(); ++b)
						{
							if (((pt[s].x == te[b].x1) && (pt[t].x == te[b].x2) && (pt[s].z == te[b].z1) && (pt[t].z == te[b].z2))
								or ((pt[t].x == te[b].x1) && (pt[s].x == te[b].x2) && (pt[t].z == te[b].z1) && (pt[s].z == te[b].z2)))
							{	
								for (int c = 0; c < se.size(); ++c)
								{
									if (((pt[s].y == se[c].y1) && (pt[t].y == se[c].y2) && (pt[s].z == se[c].z1) && (pt[t].z == se[c].z2))
										or ((pt[t].y == se[c].y1) && (pt[s].y == se[c].y2) && (pt[t].z == se[c].z1) && (pt[s].z == se[c].z2)))
									{	
										ln.push_back(edge(pt[s].x,pt[s].y,pt[s].z, pt[t].x,pt[t].y,pt[t].z));
										break;
									}
								}
							}
						}
					}
				}

			}
		}

		//-------------PRINT 3D VERTICES----------------------
		cout<<"3D points"<<endl;
		for (int p = 0; p < pt.size(); ++p)
		{
			cout<<"(" <<pt[p].x <<"," <<pt[p].y <<"," <<pt[p].z <<")" <<endl;
		}

		//--------------3D Edges----------------
		cout<<"Edges"<<endl;
 		cout<<"(" <<ln[0].x1 <<"," <<ln[0].y1 <<"," <<ln[0].z1 <<")" <<" "<<"(" <<ln[0].x2 <<"," <<ln[0].y2 <<"," <<ln[0].z2 <<")" <<endl;
		for (int i = 1; i < ln.size(); ++i)
		{
			bool t = true;
			for (int j = i-1; j >= 0; --j)
			{
				if ((ln[j].x1==ln[i].x1) && (ln[j].y1==ln[i].y1) && (ln[j].z1==ln[i].z1) && (ln[j].x2==ln[i].x2) && (ln[j].y2==ln[i].y2) && (ln[j].z2==ln[i].z2))
				{
					t = false;
				}
			}
			if (t==true)
			{
				cout<<"(" <<ln[i].x1 <<"," <<ln[i].y1 <<"," <<ln[i].z1 <<")" <<" " <<"(" <<ln[i].x2 <<"," <<ln[i].y2<<"," <<ln[i].z2 <<")" <<endl;
			}
		}
	

	}
	
};

//-------------------------------  3D to 2D --------------------------------------------------========================
//---------------------------------------------------------------------------------------------======================
class threedtotwod{
public:
	std::vector<vertex> vertices;
	std::vector<edge> edges;

	std::vector<vertex> vf;
	std::vector<vertex> vt;
	std::vector<vertex> vs;

	std::vector<edge> ef;
	std::vector<edge> et;
	std::vector<edge> es;

	std::vector<vertex> front_proj;
	std::vector<vertex> side_proj;
	std::vector<vertex> top_proj;

	std::vector<edge> front_edge;
	std::vector<edge> top_edge;
	std::vector<edge> side_edge;

// // ----------------------- FRONT VIEW ---------------------
	void create_frontview (){
		for (int i = 0; i < vertices.size(); ++i)
		{
			vf.push_back(vertex(vertices[i].x, vertices[i].y, 0));
			ef.push_back(edge(edges[i].x1, edges[i].y1, 0, edges[i].x2, edges[i].y2, 0 ));

		}

		cout<<"Front View"<<endl;
		cout<<"Vertices of Front view"<<endl;
		print_proj(front_proj, vf);
		cout<<"Edges of Front view"<<endl;
		print_edge(front_edge, ef);	
	}

//--------------- ----------- TOP VIEW ------------------------
	void create_topview (){
		for (int i = 0; i < vertices.size(); ++i)
		{
			vt.push_back(vertex(vertices[i].x, 0, vertices[i].y));
			et.push_back(edge(edges[i].x1, 0, edges[i].z1, edges[i].x2, 0, edges[i].z2 ));
		}
		cout<<"Top View"<<endl;
		cout<<"Vertices of Top view"<<endl;
		print_proj(top_proj, vt);
		cout<<"Edges of Top view"<<endl;
		print_edge(front_edge, et);	
	}

//-------------------------- SIDE VIEW ----------------------
	void create_sideview (){
		for (int i = 0; i < vertices.size(); ++i)
		{
			vs.push_back(vertex(0, vertices[i].y, vertices[i].z));
			es.push_back(edge(0, edges[i].y1, edges[i].z1, 0, edges[i].y2, edges[i].z2));
		}
		cout<<"Side View"<<endl;
		cout<<"Vertices of Side view"<<endl;
		print_proj(side_proj, vs);
		cout<<"Edges of Side view"<<endl;
		print_edge(side_edge, es);
	}

//------------------- PRINT PROJEvtIOS -----------------
	void print_proj(vector<vertex> v_out, vector<vertex> v){
		v_out.push_back(vertex(v[0].x, v[0].y, v[0].z ));
		cout<<"(" <<v[0].x <<"," <<v[0].y <<"," <<v[0].z <<")" <<endl;
		for (int i = 1; i < (v.size()); ++i)
		{
			bool t = true;
			for (int j = i-1; j >= 0; --j)
			{
				if ((v[j].x==v[i].x) && (v[j].y==v[i].y) && (v[j].z==v[i].z))
				{
					t = false;
				}
			}
			if (t==true)
			{
				v_out.push_back(vertex(v[i].x, v[i].y, v[i].z ));
				cout<<"(" <<v[i].x <<"," <<v[i].y <<"," <<v[i].z <<")" <<endl;
			}
		}
	}

//--------------------- PRINT EDGES ------------------------
	void print_edge(vector<edge> v_out, vector<edge> v){
		v_out.push_back(edge(v[0].x1, v[0].y1, v[0].z1, v[0].x2, v[0].y2, v[0].z2 ));
		cout<<"(" <<v[0].x1 <<"," <<v[0].y1 <<"," <<v[0].z1 <<")" <<" " <<"(" <<v[0].x2 <<"," <<v[0].y2 <<"," <<v[0].z2 <<")" <<endl;
		for (int i = 1; i < v.size(); ++i)
		{
			bool t = true;
			for (int j = i-1; j >= 0; --j)
			{
				if (((v[j].x1==v[i].x1) && (v[j].y1==v[i].y1) && (v[j].z1==v[i].z1) && (v[j].x2==v[i].x2) && (v[j].y2==v[i].y2) && (v[j].z2==v[i].z2))
					or ((v[i].x1==v[i].x2) && (v[i].y1==v[i].y2) && (v[i].z1==v[i].z2)))
				{
					t = false;
				}
			}
			if (t==true)
			{
				v_out.push_back(edge(v[i].x1, v[i].y1, v[i].z1, v[i].x2, v[i].y2, v[i].z2));
				cout<<"(" <<v[i].x1 <<"," <<v[i].y1 <<"," <<v[i].z1 <<")" <<" " <<"(" <<v[i].x2 <<"," <<v[i].y2 <<"," <<v[i].z2 <<")" <<endl;
			}
		}
	}


};



int main()
{
	int i;

	cout<<"Press 1 for 2D to 3D"<<endl;
	cout<<"Press 2 for 3D to 2D"<<endl;
	cin>> i;

	if (i==1)
	{
		twodtothreed obj;

		std::ifstream infile("in2d.txt");
		std::string line;
		while (std::getline(infile, line))
		{
		    std::istringstream iss(line);
		    int a, b, c;
		    if (!(iss >> a >> b >> c)) { break; } // error

			obj.fv.push_back(vertex(a, b, c));		   
		}
		while (std::getline(infile, line))
		{
		    std::istringstream iss(line);
		    int a, b, c;
		    if (!(iss >> a >> b >> c)) { break; } // error

		    obj.tv.push_back(vertex(a, b, c));
		}

		while (std::getline(infile, line))
		{
		    std::istringstream iss(line);
		    int a, b, c;
		    if (!(iss >> a >> b >> c)) { break; } // error

		    obj.sv.push_back(vertex(a, b, c));
		}

		while (std::getline(infile, line))
		{
		    std::istringstream iss(line);
		    int a, b , c, d, e, f;
		    if (!(iss >> a >> b >> c >> d >> e >> f)) { break; } // error

		    obj.fe.push_back(edge(a, b, c, d, e, f));
		}

		while (std::getline(infile, line))
		{
		    std::istringstream iss(line);
		    int a, b , c, d, e, f;
		    if (!(iss >> a >> b >> c >> d >> e >> f)) { break; } // error

		    obj.te.push_back(edge(a, b, c, d, e, f));
		}

		while (std::getline(infile, line))
		{
		    std::istringstream iss(line);
		    int a, b , c, d, e, f;
		    if (!(iss >> a >> b >> c >> d >> e >> f)) { break; } // error

		    obj.se.push_back(edge(a, b, c, d, e, f));
		}

		obj.crete3D();
	}

	else if(i==2)
	{
		threedtotwod obj1;

		std::ifstream infile("in3d.txt");
		std::string line;
		while (std::getline(infile, line))
		{
		    std::istringstream iss(line);
		    int a, b, c;
		    if (!(iss >> a >> b >> c)) { break; } // error

			obj1.vertices.push_back(vertex(a, b, c));		   
		}
		while (std::getline(infile, line))
		{
		    std::istringstream iss(line);
		    int a, b , c, d, e, f;
		    if (!(iss >> a >> b >> c >> d >> e >> f)) { break; } // error

		    obj1.edges.push_back(edge(a, b, c, d, e, f));
		}

		obj1.create_frontview();
		obj1.create_topview();
		obj1.create_sideview();	

	}

	else{cout<<"Please enter correvt value"<<endl;}

		
}