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();
}
Cuadrilatero::Cuadrilatero(Punto p1,Punto p2,Punto p3,Punto p4, Transformacion t)
{
vert=new Punto[4];
nvertices=4;
vert[0]= p1.transform(t);
vert[1]= p2.transform(t);
vert[2]= p3.transform(t);
vert[3]= p4.transform(t);
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;
}
// Constructor
Triangulo::Triangulo(Punto p0, Punto p1, Punto p2) {
// Vertices en sentido antihorario
vertices.push_back(p0);
vertices.push_back(p1);
vertices.push_back(p2);
zmax = max(p0.z,p1.z,p2.z);
tipo = OTRO;
posicion = (p0 + p1 + p2) / 3;
Punto normal = (p2-p1)^(p0-p2);
normal.normalizar();
normales.push_back(normal);
material = Material(RGB(0,1,0),0.5,0.5);
// Proyectamos el polígono en el plano
if (fabs(normales[0].x) > fabs(normales[0].y) && fabs(normales[0].x) > fabs(normales[0].z)) {
// Proyectamos sobre las X
proyecc = 1;
i0 = proyecc - 1;
i1 = 1;
i2 = 2;
}
else if (fabs(normales[0].y) > fabs(normales[0].x) && fabs(normales[0].y) > fabs(normales[0].z)) {
// Proyectamos sobre las Y
proyecc = 2;
i0 = proyecc - 1;
i1 = 0;
i2 = 2;
}
else {
// Proyectamos sobre las Z
proyecc = 3;
i0 = proyecc - 1;
i1 = 0;
i2 = 1;
}
// i1 = (i0-1)%3;
// i2 = (i0+1)%3;
};
void MovimientosAUV::moverNodosSegunParametro(int indice, double valor, Malla *malla){
int nNodos = malla->getMaxIndiceNodos();
double xs[nNodos +1];
double ys[nNodos +1];
double zs[nNodos +1];
for(int i = 0; i <= nNodos; ++i){
xs[i] = 0.0;
ys[i] = 0.0;
zs[i] = 0.0;
}
for(int i = 0; i < malla->getNodos()->n_marcados; ++i){
Punto *p = this->getMovimiento(i, indice);
int ind = malla->getNodos()->nodos_marcados[i];
xs[ind] = p->getX();
ys[ind] = p->getY();
zs[ind] = p->getZ();
}
for(int i = 0; i <= nNodos; ++i){
Nodo *n = malla->getNodo(i);
int i1 = n->getAsociado1();
int i2 = n->getAsociado2();
int i3 = n->getAsociado3();
if(i1<0 || i2<0 || i3<0)
continue;
float coef1 = n->getCoef1();
float coef2 = n->getCoef2();
float coef3 = n->getCoef3();
float newX = n->getPunto().getX() + coef1*xs[i1]*valor + coef2*xs[i2]*valor + coef3*xs[i3]*valor;
float newY = n->getPunto().getY() + coef1*ys[i1]*valor + coef2*ys[i2]*valor + coef3*ys[i3]*valor;
float newZ = n->getPunto().getZ() + coef1*zs[i1]*valor + coef2*zs[i2]*valor + coef3*zs[i3]*valor;
n->setPunto(Punto(newX, newY, newZ));
}
}
void RenderRayTracer::renderiza(Escena escena, Camara c) {
RGB color;
// float i,j;
int i,j;
float alfa = (c.fov*PI)/360.0;
float dist = 0.5/tan(alfa);
float incx = 1.0/(float)ancho*1.0;
float incy = 1.0/(float)alto*1.0;
float aspectratio = (float)ancho/(float)alto;
float alfaw = alfa*aspectratio;
float ancho_a = tan(alfaw)*dist;
Punto centro = c.posicion + (c.look - c.posicion).normalizar()*dist;
// Vector horizontal y vertical por los que se mueve
Punto horizontal = up^(c.look - c.posicion);
horizontal.normalizar();
Punto vertical = (c.look - c.posicion).normalizar()^horizontal;
vertical.normalizar();
Punto direccion = centro - horizontal*ancho_a - vertical*0.5;
for(i=0;i<ancho;i++) {
for(j=0;j<alto;j++) {
// trazamos un rayo desde centro hasta x,y -> devuelve un color
//
// (direccion+horizontal*i*incx+vertical*j*incy - c.posicion).escribir();
//
color = escena.trazarRayo(c.posicion,(direccion+horizontal*i*incx+vertical*j*incy - c.posicion).normalizar(),1,-1,1);
raster.push_back(color);
}
}
cerr << "Tiempo renderizado: ";
};
bool Triangulo::enCuadradoSelec(Punto p){
Punto arrIzq,arrDer,abaIzq,abaDer;
arrIzq = areaArribaIzq();
arrDer = areaArribaDer();
abaDer = areaAbajoDer();
abaIzq = areaAbajoIzq();
bool dentro = (arrIzq.getX()<=p.getX()) && (arrIzq.getY()<=p.getY()) &&
(arrDer.getX()>=p.getX()) && (arrDer.getY()<=p.getY()) &&
(abaIzq.getX()<=p.getX()) && (abaIzq).getY()>=p.getY() &&
(abaDer.getX()>=p.getX()) && (abaDer.getY()>=p.getY());
return dentro;
}
Transformacion Transformacion::rotation(float ang, Vector vectorEje, Punto enRecta )
//Acumula el giro alrededor de un eje generico
{
float lat,lon;
lat= vectorEje.latitude(); //latitud
lon= vectorEje.longitude(); //longitud
//Recordar acumulacion LIFO
translation(enRecta); //Rehacer la traslacion
rotY(lon); //Rehacer la longitud
rotX(-lat); //Rehacer la latitud
rotZ(ang); //Girar el angulo
rotX(lat); //Deshacer la latitud
rotY(-lon); //Deshacer la longitud
return translation(enRecta.negated()); //Traslacion al origen
}
void Triangulo::moverFig (int x,int y){
Punto p;
int auxx, auxy;
p= getP1();
auxx= p.getX()+x;
auxy= p.getY()+y;
setP1(Punto(auxx,auxy));
p= getP2();
auxx= p.getX()+x;
auxy= p.getY()+y;
setP2(Punto(auxx,auxy));
p= getP3();
auxx= p.getX()+x;
auxy= p.getY()+y;
setP3(Punto(auxx,auxy));
}
void displayTeapot(Camara &cam, Transformacion marco){
//Dibuja la foto de un Cubo con la cam y la pone en t
// Transformacion de la camara
Transformacion rotcam;
Transformacion rotationx, rotationy;
Punto newAT = AT;
rotationx.rotX(rotationX);
rotationy.rotY(rotationY);
newAT = newAT.transform(rotationx);
newAT = newAT.transform(rotationy);
Punto vert = Punto(0.0, 1.0, 0.0);
vert.transform(rotcam);
canon.at(newAT);
canon.lookAt(OR);
canon.setVertical(vert.asVector());
Punto newFR = FR;
newFR = newFR.transform(rotationy);
frontal.at(newFR);
frontal.lookAt(OR);
Punto newPE = PE;
newPE = newPE.transform(rotationy);
perfil.at(newPE);
perfil.lookAt(OR);
Punto newCE = CE;
newCE = newCE.transform(rotationy);
cenital.setVertical(newCE.asVector());
rotationx.reset();
rotationy.reset();
Transformacion t = marco * cam.getview();
//Dibujo de la tetera
Transformacion rot;
rot.rotX(-90);
Transformacion mov;
mov.translation(Real4(0.0, -1.0, 0.0));
for(int k=0;k<32;k++){
S[k].getPoints(NVERT, sb);
S[k].getTangents(NVERT, tgU, tgV);
S[k].getNormals(NVERT, n);
for(int i=0;i<NVERT*NVERT;i++){
sb[i] = sb[i].transform(rot).transform(mov);
sb[i] = cam.shot(sb[i]).transform(marco);
float sup_color[] = {0.5, 0.5, 0.5, 1.0}; //Gris
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, sup_color);
}
if(inalambrico){
for(int i=0;i<NVERT-1;i++){
for(int j=0;j<NVERT-1;j++){
glBegin(GL_QUADS);
glNormal3f(n[NVERT*i+j].x(),n[NVERT*i+j].y(),n[NVERT*i+j].z());
glVertex3f(sb[NVERT*i+j].x(),sb[NVERT*i+j].y(),sb[NVERT*i+j].z());
glNormal3f(n[NVERT*(i+1)+j].x(),n[NVERT*(i+1)+j].y(),n[NVERT*(i+1)+j].z());
glVertex3f(sb[NVERT*(i+1)+j].x(),sb[NVERT*(i+1)+j].y(),sb[NVERT*(i+1)+j].z());
glNormal3f(n[NVERT*(i+1)+(j+1)].x(),n[NVERT*(i+1)+(j+1)].y(),n[NVERT*(i+1)+(j+1)].z());
glVertex3f(sb[NVERT*(i+1)+(j+1)].x(),sb[NVERT*(i+1)+(j+1)].y(),sb[NVERT*(i+1)+(j+1)].z());
glNormal3f(n[NVERT*i+(j+1)].x(),n[NVERT*i+(j+1)].y(),n[NVERT*i+(j+1)].z());
glVertex3f(sb[NVERT*i+(j+1)].x(),sb[NVERT*i+(j+1)].y(),sb[NVERT*i+(j+1)].z());
glEnd();
};
};
}
else{
for(int i=0;i<NVERT;i++){
glBegin(GL_LINE_STRIP);
for(int j=0;j<NVERT;j++){
glVertex3f( (GLfloat)((sb[i*NVERT+j]).x()),
(GLfloat)((sb[i*NVERT+j]).y()),
(GLfloat)((sb[i*NVERT+j]).z()));
}
glEnd();
}
for(int i=0;i<NVERT;i++){
glBegin(GL_LINE_STRIP);
for(int j=0;j<NVERT;j++){
glVertex3f( (GLfloat)((sb[i+j*NVERT]).x()),
(GLfloat)((sb[i+j*NVERT]).y()),
(GLfloat)((sb[i+j*NVERT]).z()));
}
glEnd();
}
}
}
}
Malla* GeneraCilindro::generaMallaTriangulos() {
//Genero la medula.
vector<Punto> medula;
medula.push_back(Punto(0,0,0));
medula.push_back(Punto(0,altura,0));
nodos = new Nodos();
Nodo *nodo;
Punto p;
Vect v, v1, v2;
double h,angulo;
h = altura / num_anillos;
angulo = 2*PI / num_puntos;
for(int i=0; i<num_anillos; i++) {
for(int j=0; j<num_puntos; j++) {
p = Punto(cos(j*angulo)*radio,i*h-h/2,sin(j*angulo)*radio);
v1 = Vect(p.getX(),p.getY(),p.getZ());
v2 = Vect(0,i*h-h/2,0);
v = v1 - v2;
nodo = new Nodo(p);
nodo->setNormal(v); //le seteamos su normal
nodo->setConcentracion(0.0); // le seteamos su concentracion
nodos->addNodo(nodo);
}
}
arcos = new Arcos();
caras = new Caras();
int n0, n1, n2, n3;
for(int i=0; i<num_anillos-1; i++) {
for(int j=0; j<num_puntos; j++) {
n0 = num_puntos*i+j;
n1 = num_puntos*i+((j+1)%num_puntos);
n2 = num_puntos*(i+1)+j;
n3 = num_puntos*(i+1)+((j+1)%num_puntos);
if (i%2==0){ //Para que se vayan alternando los arcos.
arcos->addArco(new Arco(n0, n1));
arcos->addArco(new Arco(n0, n2));
arcos->addArco(new Arco(n0, n3));
caras->addCara(new Triangulo(n0,n3,n1));
caras->addCara(new Triangulo(n0,n2,n3));
}
else{
arcos->addArco(new Arco(n0, n1));
arcos->addArco(new Arco(n0, n2));
arcos->addArco(new Arco(n1, n2));
caras->addCara(new Triangulo(n1,n2,n3));
caras->addCara(new Triangulo(n0,n2,n1));
}
if(i==num_anillos-2) //Generamos los arcos del borde superior.
arcos->addArco(new Arco(n2, n3));
}
}
updateVecinos();
Malla *malla = new MallaTriangulos(nodos,arcos,caras);
malla->setMedula(medula);
malla->setConcentracionMax(1.0);
malla->setConcentracionMin(0.0);
assert(malla->checkMalla(true) >= 0);
return malla;
}
Vector Punto::operator -(const Punto &p)const
//Resta de puntos genera vector
{
return Vector(x()-p.x(),y()-p.y(),z()-p.z());
}
