C++ Punto类代码示例

int Nodos::addNodo(Nodo* n) {
    Punto p = n->getPunto();
		    double x = p.getX();
		    double y = p.getY();
		    double z = p.getZ();
		    if(x>maxx) maxx = x;
		    if(x<minx) minx = x;
		    if(y>maxy) maxy = y;
		    if(y<miny) miny = y;
		    if(z>maxz) maxz = z;
		    if(z<minz) minz = z;


    // Si existe un indice en que haya un punto que fue borrado insertamos el punto ahi.
    if(borrados.size() > 0) {
        int ind = borrados[0];
        nodos[ind] = n;
        borrados.erase(borrados.begin());
        num_nodos_validos++; // actualizamos el numero de nodos validos
        return ind;
    }
    else {
        nodos.push_back(n); // agregamos el punto al contenedor.
        num_nodos++; // actualizamos el numero de nodos del contenedor
        num_nodos_validos++; // actualizamos el numero de nodos validos
        return (nodos.size()-1);
    }
}

void Flecha::drawAt(const Punto &en) const
{
	float largo= vector.module();
	Punto punta= en+vector;
	glColor3f(color.r(),color.g(),color.b());
	if(largo<0.001){ //Es muy pequeño o nulo; lo dibujamos como un punto
		glPointSize(4.0);
		glBegin(GL_POINTS);
			glVertex3d(punta.x(),punta.y(),punta.z());
		glEnd();
	}
	else { //Si es más grande como un flecha
		glBegin(GL_LINES);
			glVertex3d(en.x(),en.y(),en.z());
			glVertex3d(punta.x(),punta.y(),punta.z());
		glEnd();
		glPushMatrix();
		glTranslatef(punta.x(),punta.y(),punta.z());
		glRotatef(vector.longitude(),0.0,1.0,0.0);
		glRotatef(-vector.latitude(),1.0,0.0,0.0);
		glTranslatef(0.0,0.0,-largo/10.0);
		glutWireCone(largo/50.0,largo/10.0,10,1);
		glPopMatrix();
	};
}

void Obstaculo::calTTC(float v, float antiguo)
{   float m ;
    float b;
     if(dir->getx()==0)
      m =  0;
     else
      m = dir->gety()/dir->getx();
    if(dir->getx()==0 || m==0) b = centro->gety();
    else
     b = centro->gety()/(m*centro->getx());
    Punto* corte = new Punto(0.0,b,90);

    if (b>0 && velocidad > 0 && v>0)
    {
        float tobstaculo = (centro->distanciaPunto(corte))/(velocidad/3.6);
        Punto* coche = new Punto(0,0,90);
        float tcoche = (coche->distanciaPunto(corte))/(v/3.6);
        if (fabs(tobstaculo-tcoche) > 10)
            TTC = -1;
        else
        {
            if (antiguo!=-1)
                TTC = (tobstaculo + antiguo)/2;
            else TTC = tobstaculo;
            if(TTC-antiguo<0.1)
                TTC=-1;
        }
    }
    else TTC = -1;
}

Nodos::Nodos(vector<Nodo*> nds) {
    num_nodos = nds.size();
    num_nodos_validos = nds.size();
    nodos = nds;
    double mx = -1*numeric_limits<float>::max();
    double mix = numeric_limits<float>::max();
    double my = -1*numeric_limits<float>::max();
    double miy = numeric_limits<float>::max();
    double mz = -1*numeric_limits<float>::max();
    double miz = numeric_limits<float>::max();
    for(int i = 0; i < (int)nds.size(); ++i){
        Nodo* n = nds[i];
		if( n!= 0){
		    Punto p = n->getPunto();
		    double x = p.getX();
		    double y = p.getY();
		    double z = p.getZ();
		    if(x>mx) mx = x;
		    if(x<mix) mix = x;
		    if(y>my) my = y;
		    if(y<miy) miy = y;
		    if(z>mz) mz = z;
		    if(z<miz) miz = z;
		}
    }
    this->maxx = mx;
    this->minx = mix;
    this->maxy = my;
    this->miny = miy;
    this->maxz = mz;
    this->minz = miz;

    nodos_marcados = NULL;
}

double Triangulo::distanciaCentroide(Punto p){
    Punto centr = centroide();
    int auxx,auxy;
    auxx = pow((p.getX() - centr.getX()),2);
    auxy = pow((p.getY() - centr.getY()),2);
    return sqrt(auxx+auxy);
}

Punto Punto::transform(const Transformacion &t)const
//Devuelve el punto transformado
{
	Punto p;
	for(int i=0;i<4;i++) p.setelem(i,t.row(i)*(*this));
	return p;
}

void renderFunction(){
	glClear(GL_COLOR_BUFFER_BIT); 
	glColor(Color::amarillo);
	for(int i=-radio;i<=radio;i++){
		for(int j=-radio;j<=radio;j++){
			if(i*i+j*j <= radio*radio + radio/2){
				glDraw(centroSol+Punto<double>(i,j));
			}
		}
	}

	for(particula& p: v){
		Punto<double> dist = centroSol - p.posicion;
		double r = dist.norma2();

		p.dibujar();
		p.aceleracion+=(dist)*(1.0/r)*particula::dt*g;
		p.iterar();
	}



	glFlush();
	glutSwapBuffers();
	glutTimerFunc(1, (void(*)(int))renderFunction,0);
}

int main()
{
  Punto* p = new Punto();

  cout<<"("<<p->get_X()<<", "<<p->get_Y()<<")";

  return 0;
}

Triangulo::Triangulo(Punto p1,Punto p2,Punto p3, Transformacion t) 
{
	vert=new Punto[3];
	vert[0]= p1.transform(t);
	vert[1]= p2.transform(t);
	vert[2]= p3.transform(t);
	nvertices= 3;
	N= ((vert[1]-vert[0])^(vert[2]-vert[1])).unitary();

}

int main()
{
    cout << "Prueba C++" <<endl;
    cout << "Constructor Punto" <<endl;
    Punto coordenadas = Punto();
    coordenadas.Mostrar();
    cout << "Constructor de copia Punto" <<endl;
    Punto coordenadas2 = coordenadas;
    coordenadas2.Mostrar();
    cout << "Constructor de copia generado Punto" <<endl;
    Punto coordenadas3 = Punto(coordenadas);
    coordenadas3.Mostrar();
    cout << "Constructor de un solo parametro" <<endl;
    Punto coordenadas4 = Punto(102);
    coordenadas4.Mostrar();
    cout << "Constructor con 2 parametro" <<endl;
    Punto coordenadas5 = Punto(1028,1028);
    coordenadas5.Mostrar();
    cout << "Constructor con 2 parametro con valores por defecto" <<endl;
    Punto coordenadas6 = Punto();
    coordenadas6.Mostrar();
    coordenadas = coordenadas2 = coordenadas4;
    coordenadas.Mostrar();
    coordenadas2.Mostrar();
    cout <<"Operador asignacion"<<endl;
    coordenadas4 = coordenadas5;
    coordenadas4.Mostrar();
    cout <<"Operador << sobrecargado"<<endl;
    cout <<coordenadas4<<endl;
    cout <<"Operador >> sobrecargado"<<endl;
    cin >> coordenadas4;
    cout << coordenadas4 << endl;
    cout <<"Operador ++ (pos) sobrecargado"<<endl;
    coordenadas2 = coordenadas4 ++;
    cout <<"coodenadas2 :" <<coordenadas2 << endl;
    cout <<"coordenadas4 :" << coordenadas4 << endl;
    cout <<"Operador ++ (pre) sobrecargado"<<endl;
    coordenadas3 = ++coordenadas4;
    cout <<"coodenadas3 :" <<coordenadas3 << endl;
    cout <<"coordenadas4 :" << coordenadas4 << endl;
    cout <<"Operador + sobrecargado"<<endl;
    coordenadas6 = coordenadas2 + coordenadas5;
    cout <<"coordenadas6 :"<<coordenadas6<<endl;
    cout <<"Operador - sobrecargado"<<endl;
    coordenadas5 = coordenadas6 - coordenadas2;
    cout <<"coordenadas5 :"<<coordenadas5<<endl;
    cout <<"Operador + sobrecargado con otro objeto a la derecha"<<endl;
    coordenadas2 = coordenadas5 + 7;
    cout <<"coordenadas2 :"<<coordenadas2<<endl;
    cout <<"Operador + sobrecargado con otro objeto a la izquierda"<<endl;
    coordenadas2 = 7 + coordenadas5;
    cout <<"coordenadas2 :"<<coordenadas2<<endl;
    return 0;
}

void Poligono::drawWith(const Transformacion &T)const
//Dibuja el poligono solido (como Primitiva)
{	
	Vector Nt = N.transform( !(T.inverse3x3()) );
	glColor3f(color.r(),color.g(),color.b());
	glBegin(GL_POLYGON);
	glNormal3f(Nt.x(),Nt.y(),Nt.z());
	for(int i=0; i< nvertices; i++){
		Punto vertt = vert[i].transform(T);
		glVertex3f(vertt.x(),vertt.y(),vertt.z());
	}
	glEnd();
}

int main() {
	
	std::cout << "******************************************************************" << std::endl;
	std::cout << "* Ejemplos de Instanciacion de Objetos creados Dinamicamente     *" << std::endl;
	std::cout << "******************************************************************" << std::endl;
	
	std::cout << "Primer ejemplo de Instanciacion de un objeto de la Clase Punto." << std::endl;
	Punto* punto = new Punto(1.5, 6.836423);
	std::cout << "Punto(" << punto->getX() << ", " << punto->getY() << ")" << std::endl << std::endl;
	
	std::cout << "Segundo ejemplo de Instanciacion de un objeto de la Clase Figura." << std::endl;
	Figura* figura = new Figura(4);
	std::cout << "Figura(" << figura->getNumPuntos() << ")" << std::endl << std::endl;
	return 0;
}

int Esfera::puntosInterseccion(Punto p, Punto u, float *t) {

	// Vector u = Origen + t*(Destino)
	// t : incognita
	// Q = Origen = p
	// V = Destino  
	// rayo = p + t*u

	bool v = false;
	float t1,t2;

	u.normalizar();

	Punto Q = p - posicion;
	Punto V = u;
	
	float a = V*V;
	float b = 2*(Q*V);
	float c = (Q*Q) - radio*radio;

	//
	// if (v) cerr << "a: "<<a<<" - b: "<<b<<" - c: "<<c<<endl;
	// 
	
	// Cogemos, de las dos soluciones, la negativa, porque es la que antes 
	// intersectará de las dos
	float D = b*b - 4*a*c;
	//
	// if (v) cerr << "D: "<<D<<" " <<sqrt(D)<<endl;
	// 
	if (D < 0) {
		return 0;
	}
	else {
		t1 = (-b - sqrt(D)) / (2*a);
		if (D == 0) {
			*t = t1;
			return 1;
		}
		t2 = (-b + sqrt(D)) / (2*a);
		if (t1 > t2) {
			*t = t2;
			return 1;
		}
		*t = t1;
		return 1;
	}
		//
		// if ((t1 > 0 && t2 <0)) {
		// 	*t = t1;
		// 	return 1;
		// }
		// if ((t1 < 0 && t2>0)) {
		// 	*t = t2;
		// 	return 1;
		// }
		// 
			
	
};

Transformacion Transformacion::scale(float sx,float sy,float sz, Punto centro)
//Acumula el escalado sobre un punto generico
{
	Matriz s;
	translation(centro);
	s.setelem(0,0,sx); s.setelem(1,1,sy); s.setelem(2,2,sz);
	append(s);
	return translation(centro.negated());
}

Focalizada::Focalizada(Punto centro_, Punto direccion_, float factor_) {

		centro = centro_; 	
		factor = factor_;
		direccion = direccion_.normalizar();
		i = RGB(1,1,1); 		
		n = 200; 
		tipo = FOCALIZADA;
}