/*
=======================================================================================================================
=======================================================================================================================
*/
FlipFlop::FlipFlop(int n1, int x1, int y1)
{
n = n1;
CLK = Punto(x1, y1);
// J=Punto (x1,y1-15); K=Punto (x1,y1+15);
Q = Punto("Q" + IntToStr(n), x1 + 70, y1 - 15);
NQ = Punto("~Q" + IntToStr(n), x1 + 70, y1 + 15);
RESET = Punto(x1 + 35, y1 + 35);
}
void myinit(void){
glClearColor (1.0, 1.0, 1.0, 1.0);
//Camara perspectiva
canon.at(AT);
canon.lookAt(OR);
canon.setVertical(Vector(0.0, 1.0, 0.0));
//Camara en el techo - Planta
cenital.at(Punto(0.0, 2.0, 0.0));
cenital.lookAt(OR);
cenital.setVertical(Vector(0.0, 0.0, -1.0));
cenital.setHeight(ALTO);
//Cámara de perfil - Perfil
perfil.at(Punto(2.0, 0.0, 0.0));
perfil.lookAt(OR);
perfil.setVertical(Vector(0.0, 1.0, 0.0));
perfil.setHeight(ALTO);
//Cámara de frente - Alzado
frontal.at(Punto(0.0, 0.0, 2.0));
frontal.lookAt(OR);
frontal.setVertical(Vector(0.0, 1.0, 0.0));
frontal.setHeight(ALTO);
//Transformaciones de las fotos (LIFO)
NO.translation(Vector(-DESP, DESP, 0.0));
NO.scale(0.5, 0.5);
NE.translation(Vector( DESP, DESP, 0.0));
NE.scale(0.5, 0.5);
SO.translation(Vector(-DESP, -DESP, 0.0));
SO.scale(0.5, 0.5);
SE.translation(Vector( DESP, -DESP, 0.0));
SE.scale(0.5, 0.5);
//Inicializacion de la iluminacion
GLfloat light_position[] = {4.0, 9.0,-4.0, 0.0};
GLfloat mat_ambient [] = {0.5, 0.5, 0.5, 1.0};
GLfloat mat_diffuse [] = {0.0, 0.0, 0.0, 1.0};
GLfloat mat_specular [] = {0.9, 0.9, 0.9, 1.0};
GLfloat mat_shininess [] = {5.0};
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_DEPTH_TEST);
glShadeModel(GL_SMOOTH);
}
Ambiental::Ambiental() {
centro = Punto();
i = RGB(1,1,1);
n = 50;
tipo = AMBIENTAL;
}
int main (int argc, char* argv[]){
ifstream f_paises ("./datos/paises.txt");
Paises almacenPaises("./datos/imagenes/banderas");
cin.get();
f_paises >> almacenPaises;
almacenPaises[Punto(34.520418555522845,69.20082090000005)].bandera.escribir("./prueba.ppm","PPM");
}
void traza(void) {
int i, j;
Color color;
double x1, y1, a, b;
unsigned char *t;
//Si es la primera vez, o hay que redibujar la escena...
if(raster==NULL){
raster = (unsigned char *)malloc(sizeof(unsigned char)*3*ancho*alto);
if (raster==NULL){
fprintf(stderr, "Sin memoria\n");
exit(-1);
}
}
b = calc_b(pos_z, fov);
a = AspectRatio * b;
t = raster;
for(j=0; j<alto; j++){
y1 = calc_y1(b, alto, j);
for(i=0; i<ancho; i++){
x1 = calc_x1(a, ancho, i);
color = escena->rayTrace(Punto(0, 0, pos_z), Vector(x1, y1, -pos_z), 0);
*t++ = (unsigned char)(color.r()*255);
*t++ = (unsigned char)(color.g()*255);
*t++ = (unsigned char)(color.b()*255);
}
}
sucio = 0;
}
void crear_iluminacion(void){
FuenteLuminosa *ambiental, *puntual, *direccional, *focalizada;
ambiental = new Ambiental();
escena->addLight(ambiental);
puntual = new Puntual(Color(1,1,1), Punto(1,0.5,0));
escena->addLight(puntual);
focalizada = new Focalizada(Color(1,1,0), Punto(0,2,-1), Vector(0,-1,0), 8, 60);
escena->addLight(focalizada);
//direccional = new Direccional(Color(1,0,1), Vector(0,-1,0));
//escena->addLight(direccional);
}
Direccional::Direccional(Punto direccion_) {
direccion = direccion_;
centro = Punto();
i = RGB(1,1,1);
n = 100;
tipo = DIRECCIONAL;
}
void Nodos::moverNodo(int indice, double x, double y, double z, double dist) {
if(indice == -1) {
return;
}
if(indice >= (int)nodos.size() || indice < 0) {
cout << "Error: Moviendo Nodo(" << indice << "). Numero de nodos = " << nodos.size() << endl;
assert((indice < (int)nodos.size()) && (indice >= 0));
}
Nodo *n = nodos[indice];
//movemos el nodo una distancia dist.
double x1,y1,z1;
if(n != 0) {
x1=n->getPunto().getX()+x*dist;
y1=n->getPunto().getY()+y*dist;
z1=n->getPunto().getZ()+z*dist;
n->setPunto(Punto(x1,y1,z1));
}
};
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 Nodos::moverNodo(int indice, double dist) {
if(indice == -1) {
return;
}
if(indice >= (int)nodos.size() || indice < 0) {
cout << "Error: Moviendo Nodo(" << indice << "). Numero de nodos = " << nodos.size() << endl;
assert((indice < (int)nodos.size()) && (indice >= 0));
}
Nodo *n = nodos[indice];
//movemos el nodo una distancia dist.
double x,y,z;
if(n != 0) {
Vect normal = n->getNormal();
if(normal.largo() > 0) {
x=n->getPunto().getX()+normal.getPunto().getX()*dist;
y=n->getPunto().getY()+normal.getPunto().getY()*dist;
z=n->getPunto().getZ()+normal.getPunto().getZ()*dist;
n->setPunto(Punto(x,y,z));
}
}
}
void Nodos::regresarNodoSegunConcentracion(int indice, double val) {
if(indice == -1) {
return;
}
if(indice >= (int)nodos.size() || indice < 0) {
cout << "Error: Regresando Nodo(" << indice << "). Numero de nodos = " << nodos.size() << endl;
assert((indice < (int)nodos.size()) && (indice >= 0));
}
Nodo *n = nodos[indice];
//regresamos el nodo una distancia dist.
double x,y,z;
if(n != 0) {
Vect normal = n->getNormal();
if(normal.largo() > 0) {
x=n->getPunto().getX()-normal.getPunto().getX()*val*n->getConcentracion();
y=n->getPunto().getY()-normal.getPunto().getY()*val*n->getConcentracion();
z=n->getPunto().getZ()-normal.getPunto().getZ()*val*n->getConcentracion();
n->setPunto(Punto(x,y,z));
}
}
}
bool colision(int x1 , int y1 , int w1, int h1,int x2, int y2 , int w2, int h2)
{
if(puntodentrorect(Punto(x2, y2), Rectangulo(Punto(x1,y1),w1,h1)))
{
return true;
}
if(puntodentrorect(Punto(x2+w2, y2), Rectangulo(Punto(x1,y1),w1,h1)))
{
return true;
}
if(puntodentrorect(Punto(x2, y2+h2), Rectangulo(Punto(x1,y1),w1,h1)))
{
return true;
}
if(puntodentrorect(Punto(x2+w2, y2+h2), Rectangulo(Punto(x1,y1),w1,h1)))
{
return true;
}
return false;
}
Malla* GeneraFromArchivosXYZU::aplicar() {
int n_triangulos = 0, n_cuadrilateros = 0; // cantidad de caras de tres y cuatro lados
//Lineas necesarias para que scanf lea archivo en computadores seteados en otro lenguaje.
setlocale(LC_NUMERIC, "POSIX");
FILE *arch_x = fopen(archivo_x.c_str(),"r");
FILE *arch_y = fopen(archivo_y.c_str(),"r");
FILE *arch_z = fopen(archivo_z.c_str(),"r");
FILE *arch_u = fopen(archivo_u.c_str(),"r");
char line[50];
char cx[16];
char cy[16];
char cz[16];
int num_puntos, num_caras;
float x,y,z,nx,ny,nz,u;
fscanf(arch_x,"%s %s\n",line,line);
fscanf(arch_y,"%s %s\n",line,line);
fscanf(arch_z,"%s %s\n",line,line);
fscanf(arch_u,"%s %s\n",line,line);
num_puntos=0;
Nodos *nodos = new Nodos();
Nodo *nodo;
while(true) {
fscanf(arch_x,"%s %s %s\n",cx,cy,cz);
fscanf(arch_y,"%s %s %s\n",cx,cy,cz);
fscanf(arch_z,"%s %s %s\n",cx,cy,cz);
fscanf(arch_u,"%s %s %s\n",cx,cy,cz);
if(strcmp(cx,"%") == 0) {
break;
}
sscanf(cx,"%f",&x);
sscanf(cy,"%f",&y);
sscanf(cz,"%f",&z);
nodo = new Nodo(Punto(x,y,z));
nodos->addNodo(nodo);
num_puntos++;
}
map<pair<int,int>,int> ind_arcos;
map<pair<int,int>,int>::iterator iter1;
map<pair<int,int>,int>::iterator iter2;
vector<int> indice_puntos;
vector<int> indice_arcos;
Arcos *arcos = new Arcos();
Caras *caras = new Caras();
Cara *c;
int indice;
char *token;
int indices[4];
int n_lados;
num_caras=0;
while(true) {
fgets(line, 50, arch_x);
fgets(line, 50, arch_y);
fgets(line, 50, arch_z);
fgets(line, 50, arch_u);
if(strpbrk("%",line) != NULL) {
break;
}
token = strtok(line," ");
for(int i=0; i<3; ++i) {
sscanf(token,"%d",&indices[i]);
token = strtok(NULL, " ");
}
if(token == NULL) { // Caso triángulos
n_triangulos++;
n_lados = 3;
}
else { // Caso cuadriláteros
sscanf(token,"%d",&indices[3]);
n_cuadrilateros++;
n_lados = 4;
}
//Nota: Por bug en los archivos de entrada, debo invertir el orden para que las normales queden bien.
//for(int i=n_lados-1; i>=0; --i) // invertido por bug archivo entrada
for(int i=0; i<n_lados; ++i) // así debiera ser
indice_puntos.push_back(indices[i]-1);
for(int j=0; j<n_lados; j++) {
int ind1 = indice_puntos[j];
int ind2 = indice_puntos[int(fmod(j+1,n_lados))];
pair<int,int> pr1(ind1,ind2);
pair<int,int> pr2(ind2,ind1);
iter1 = ind_arcos.find(pr1);
iter2 = ind_arcos.find(pr2);
if(iter1 != ind_arcos.end())
indice_arcos.push_back(iter1->second);
else if(iter2 != ind_arcos.end())
indice_arcos.push_back(iter2->second);
else {
indice = arcos->addArco(new Arco(ind1,ind2));
indice_arcos.push_back(indice);
ind_arcos.insert(make_pair(pr1,indice));
nodos->addArcoNodo(ind1,indice);
nodos->addArcoNodo(ind2,indice);
}
}
if(n_lados == 3)
c = new Triangulo(indice_puntos,indice_arcos);
else // n_lados == 4
c = new Cuadrilatero(indice_puntos,indice_arcos);
int ind_cara = caras->addCara(c);
num_caras++;
for(int j=0; j<n_lados; j++) {
arcos->setCaraArco(indice_arcos[j],ind_cara);
nodos->addCaraNodo(indice_puntos[j],ind_cara);
}
indice_puntos.clear();
indice_arcos.clear();
}
float max_concentracion = 0;
float min_concentracion = 999999999;
for(int i=0; i<num_puntos; i++) {
fscanf(arch_x,"%f\n",&nx);
fscanf(arch_y,"%f\n",&ny);
fscanf(arch_z,"%f\n",&nz);
fscanf(arch_u,"%f\n",&u);
if(u < min_concentracion) {
min_concentracion = u;
}
if(u > max_concentracion) {
max_concentracion = u;
}
Vect normal = Vect(nx,ny,nz);
nodos->getNodo(i)->setNormal(normal);
nodos->getNodo(i)->setConcentracion(u);
}
cout << "max_concentracion = " << max_concentracion << endl;
cout << "min_concentracion = " << min_concentracion << endl;
Malla *malla = 0;
if(n_cuadrilateros == 0)
malla = new MallaTriangulos(nodos,arcos,caras);
else if(n_triangulos == 0)
malla = new MallaCuadrilateros(nodos,arcos,caras);
else
malla = new Malla(nodos,arcos,caras);
malla->setConcentracionMax(max_concentracion);
malla->setConcentracionMin(min_concentracion);
fclose(arch_x);
fclose(arch_y);
fclose(arch_z);
fclose(arch_u);
setlocale(LC_NUMERIC, "");
//Chequeamos consistencia topologica.
int V=malla->getNumNodos();
int E=malla->getNumArcos();
int F=malla->getNumCaras();
cout << "Numero de nodos=" << V << endl;
cout << "Numero de arcos=" << E << endl;
cout << "Numero de caras=" << F << endl;
if (V-E+F==2 || V-E+F==0)
cout << "La malla es consistente. Cumple la formula de Euler: V-E+F=2" << endl;
else
cout << "Atencion, la malla no es consistente. No cumple la formula de Euler: V(" << V << ")-E(" << E << "+F("<< F << ")=" << V-E+F << " y deberia ser V-E+F=2" << endl;
assert(malla->checkMalla(true) >= 0);
return malla;
}
bool VerificacionNodosVecinosColapsoRegion::checkInterseccionNodo(Malla* malla, int indNodo){
assert(malla->getNodo(indNodo)!=NULL);
Nodo* nodoActual=malla->getNodo(indNodo);
//Definimos los puntos que componen el segmento de proyeccion del nodo.
Punto PuntoProyecNodoActual= Punto( nodoActual->getPunto().getX()+nodoActual->getNormal().getPunto().getX()*val*nodoActual->getConcentracion(),
nodoActual->getPunto().getY()+nodoActual->getNormal().getPunto().getY()*val*nodoActual->getConcentracion(),
nodoActual->getPunto().getZ()+nodoActual->getNormal().getPunto().getZ()*val*nodoActual->getConcentracion());
Vect q=Vect(nodoActual->getPunto());
Vect r=Vect(PuntoProyecNodoActual);
if(q == r) // El nodo actual no se desplaza
return false;
//Revisamos cada una de las caras vecinas al nodo.
vector<int> indCarasVecinas=nodoActual->getCaras();
for (int indCara=0; indCara<(int)indCarasVecinas.size(); indCara++){
Cara* caraVecina=malla->getCara(indCarasVecinas[indCara]);
vector<int> puntos=caraVecina->getPuntosDistintos(indNodo);
//Formar paredes del cilindro que rodea la proyeccion (una por cada arco (de la cara) no incidente en indNodo)
for (int j=0; j<caraVecina->getNumElem()-2;++j) {
int indPuntoA=puntos[j];
int indPuntoB=puntos[j+1];
Nodo* NodoA=malla->getNodo(indPuntoA);
Nodo* NodoB=malla->getNodo(indPuntoB);
Punto PuntoProyecA=Punto(NodoA->getPunto().getX()+NodoA->getNormal().getPunto().getX()*val*NodoA->getConcentracion(),
NodoA->getPunto().getY()+NodoA->getNormal().getPunto().getY()*val*NodoA->getConcentracion(),
NodoA->getPunto().getZ()+NodoA->getNormal().getPunto().getZ()*val*NodoA->getConcentracion());
Punto PuntoProyecB=Punto(NodoB->getPunto().getX()+NodoB->getNormal().getPunto().getX()*val*NodoB->getConcentracion(),
NodoB->getPunto().getY()+NodoB->getNormal().getPunto().getY()*val*NodoB->getConcentracion(),
NodoB->getPunto().getZ()+NodoB->getNormal().getPunto().getZ()*val*NodoB->getConcentracion());
AdapterComputationalGeometry adapter;
char resultadoInterseccion;
if(PuntoProyecA != NodoA->getPunto()) { // Si A se desplaza
//Chequeamos interseccion con el primer triangulo
Vect triangulo1[3];
triangulo1[0]=Vect(NodoA->getPunto());
triangulo1[1]=Vect(PuntoProyecA);
triangulo1[2]=Vect(PuntoProyecB);
Vect qpoints(q.getPunto());
Vect rpoints(r.getPunto());
resultadoInterseccion=adapter.SegTriInt(triangulo1,qpoints,rpoints);
if (resultadoInterseccion!='0'){
return true;
}
}
if(PuntoProyecB != NodoB->getPunto()) { // Si B se desplaza
//Chequeamos interseccion con el segundo triangulo
Vect triangulo2[3];
triangulo2[0]=Vect(NodoB->getPunto());
triangulo2[1]=Vect(NodoA->getPunto());
triangulo2[2]=Vect(PuntoProyecB);
Vect q2points(q.getPunto());
Vect r2points(r.getPunto());
resultadoInterseccion=adapter.SegTriInt(triangulo2,q2points,r2points);
if (resultadoInterseccion!='0'){
return true;
}
}
}
}
return false;
}
Malla* GeneraFromMatLab::generaMallaCuadrilateros() {
//Lineas necesarias para que scanf lea archivo en computadores seteados en otro lenguaje.
setlocale(LC_NUMERIC, "POSIX");
FILE *mat = fopen(archivo.c_str(),"r");
float flt;
if(num_anillos == 0) {
FILE *mat2 = fopen(archivo.c_str(),"r");
if(num_puntos == 0) {
num_puntos = 90;
}
int num = 0;
while(fscanf(mat2,"%f\n",&flt) != EOF) {
num++;
}
num_anillos = num/(4*num_puntos);
fclose(mat2);
}
int num_nodos = num_anillos * num_puntos; // número de nodos de la malla
Nodos *nodos = new Nodos();
Nodo *nodo;
Punto p;
double max_concentracion = 0.0;
double min_concentracion = 99999999.0;
// Generamos los nodos de la malla, con la información en el archivo.
for(int j=0; j<4; j++) {
for(int i=0; i<num_nodos; i++) {
fscanf(mat,"%f\n",&flt);
if(j == 0) {
p = Punto(flt,0,0);
nodo = new Nodo(p);
nodos->addNodo(nodo);
}
else if(j == 1) {
Punto aux=nodos->getNodo(i)->getPunto();
aux.setZ(flt);
nodos->getNodo(i)->setPunto(aux);
}
else if(j == 2) {
Punto aux=nodos->getNodo(i)->getPunto();
aux.setY(flt);
nodos->getNodo(i)->setPunto(aux);
}
else {
if(flt < min_concentracion) {
min_concentracion = flt;
}
if(flt > max_concentracion) {
max_concentracion = flt;
}
nodos->getNodo(i)->setConcentracion(flt);
}
}
}
Arco *a;
Arcos *arcos = new Arcos();
Cara *c;
Caras *caras = new Caras();
int ind_cara, ind_arco;
int n1, n2, n3, n4;
vector<int> ind_nodos;
vector<int> ind_arcos;
for(int i=0; i<(num_anillos-1); i++) {
for(int j=0; j<num_puntos; j++) {
ind_nodos.clear();
ind_arcos.clear();
// Orden: n1 n2 n3 n4 <-> SE SO NO NE
n1 = int(fmod(num_puntos*i+j,num_nodos));
n4 = int(fmod(num_puntos*(i+1)+j,num_nodos));
if(j == num_puntos-1) {
n2 = n1-num_puntos+1;
n3 = n4-num_puntos+1;
}
else {
n2 = int(fmod(num_puntos*i+j+1,num_nodos));
n3 = int(fmod(num_puntos*(i+1)+j+1,num_nodos));
}
// Orden inverso para tener normal saliente
ind_nodos.push_back(n4);
ind_nodos.push_back(n3);
ind_nodos.push_back(n2);
ind_nodos.push_back(n1);
if(i == num_anillos-2) {
if(j == 0) {
ind_arcos.push_back(2*(n1-1)+3*num_puntos);
}
else {
ind_arcos.push_back(2*n1+j-2);
}
ind_arcos.push_back(2*n1+j);
ind_arcos.push_back(2*n1+j+1);
ind_arcos.push_back(2*(n1+1)+j);
}
else {
if(j == 0) {
ind_arcos.push_back(2*(n1+num_puntos)-1);
}
else {
ind_arcos.push_back(2*n1-1);
}
ind_arcos.push_back(2*n1);
ind_arcos.push_back(2*n1+1);
if(i == num_anillos-3) {
ind_arcos.push_back(2*n1+2*num_puntos+j);
}
else {
ind_arcos.push_back(2*n1+2*num_puntos);
}
}
c = new Cuadrilatero(ind_nodos,ind_arcos);
ind_cara = caras->addCara(c);
nodos->addCaraNodo(n1,ind_cara);
nodos->addCaraNodo(n2,ind_cara);
nodos->addCaraNodo(n3,ind_cara);
nodos->addCaraNodo(n4,ind_cara);
int ind_cara2 = -1;
if(i != 0) {
ind_cara2 = ind_cara-num_puntos;
}
a = new Arco(n1,n2,ind_cara,ind_cara2);
ind_arco = arcos->addArco(a);
nodos->addArcoNodo(n1,ind_arco);
nodos->addArcoNodo(n2,ind_arco);
ind_cara2 = ind_cara+1;
if(j == num_puntos-1) {
ind_cara2 = ind_cara-num_puntos+1;
}
a = new Arco(n2,n3,ind_cara,ind_cara2);
ind_arco = arcos->addArco(a);
nodos->addArcoNodo(n2,ind_arco);
nodos->addArcoNodo(n3,ind_arco);
if(i == num_anillos-2) {
if(j == num_puntos-1) {
a = new Arco(int(fmod(n1+num_puntos,num_nodos)),int(fmod(n1+1,num_nodos)),ind_cara,-1);
ind_arco = arcos->addArco(a);
nodos->addArcoNodo(int(fmod(n1+num_puntos,num_nodos)),ind_arco);
nodos->addArcoNodo(int(fmod(n1+1,num_nodos)),ind_arco);
}
else {
a = new Arco(int(fmod(n1+num_puntos,num_nodos)),int(fmod(n1+num_puntos+1,num_nodos)),ind_cara,-1);
ind_arco = arcos->addArco(a);
nodos->addArcoNodo(int(fmod(n1+num_puntos,num_nodos)),ind_arco);
nodos->addArcoNodo(int(fmod(n1+num_puntos+1,num_nodos)),ind_arco);
}
}
}
}
Malla *malla = new MallaCuadrilateros(nodos,arcos,caras);
malla->setConcentracionMax(max_concentracion);
malla->setConcentracionMin(min_concentracion);
malla->setNormales();
fclose(mat);
setlocale(LC_NUMERIC, "");
//Chequeamos consistencia topologica.
int V=malla->getNumNodos();
int E=malla->getNumArcos();
int F=malla->getNumCaras();
cout << "Numero de nodos=" << V << endl;
cout << "Numero de arcos=" << E << endl;
cout << "Numero de caras=" << F << endl;
if (V-E+F==2 || V-E+F==0)
cout << "La malla es consistente. Cumple la formula de Euler: V-E+F=2" << endl;
else
cout << "Atencion, la malla no es consistente. No cumple la formula de Euler: V-E+F=" << V-E+F << " y deberia ser V-E+F=2" << endl;
assert(malla->checkMalla(true) >= 0);
return malla;
}
/*
* Genera una malla de triángulos desde un archivo en formato MatLab.
* El archivo se divide en cuatro grupos de filas: primero todas las
* coordenadas x, luego todas las coordenadas z, luego las coordenadas y
* y finalmente las concentraciones en los nodos.
*/
Malla* GeneraFromMatLab::generaMallaTriangulos() {
//Lineas necesarias para que scanf lea archivo en computadores seteados en otro lenguaje.
setlocale(LC_NUMERIC, "POSIX");
FILE *mat = fopen(archivo.c_str(),"r");
float flt;
if(num_anillos == 0) {
FILE *mat2 = fopen(archivo.c_str(),"r");
if(num_puntos == 0) {
num_puntos = 90;
}
int num = 0;
while(fscanf(mat2,"%f\n",&flt) != EOF) {
num++;
}
num_anillos = num/(4*num_puntos);
fclose(mat2);
}
int num_nodos = num_anillos * num_puntos; // número de nodos de la malla
Nodos *nodos = new Nodos();
Nodo *nodo;
Punto p;
double max_concentracion = 0.0;
double min_concentracion = 99999999.0;
// Generamos los nodos de la malla, con la información en el archivo.
for(int j=0; j<4; j++) {
for(int i=0; i<num_nodos; i++) {
fscanf(mat,"%f\n",&flt);
if(j == 0) {
p = Punto(flt,0,0);
nodo = new Nodo(p);
nodos->addNodo(nodo);
}
//Invierto Y y Z para que se despliegue correctamente en la aplicacion.
else if(j == 1) {
Punto aux=nodos->getNodo(i)->getPunto();
aux.setZ(flt);
nodos->getNodo(i)->setPunto(aux);
}
else if(j == 2) {
Punto aux=nodos->getNodo(i)->getPunto();
aux.setY(flt);
nodos->getNodo(i)->setPunto(aux);
}
else {
if(flt < min_concentracion) {
min_concentracion = flt;
}
if(flt > max_concentracion) {
max_concentracion = flt;
}
nodos->getNodo(i)->setConcentracion(flt);
}
}
}
// ahora formamos los arcos y caras.
Arco *a;
Arcos *arcos = new Arcos();
Cara *c;
Caras *caras = new Caras();
int ind_cara1, ind_cara2, ind_arco;
int n1, n2, n3, n4;
int a1, a2, a3;
vector<int> ind_nodos;
vector<int> ind_arcos;
for(int i=0; i<(num_anillos-1); i++) {
for(int j=0; j<num_puntos; j++) {
ind_nodos.clear();
ind_arcos.clear();
//se deben generar 2 caras.
//cara1: n1 n2 n3
//cara2: n1 n3 n4
n1 = int(fmod(num_puntos*i+j,num_nodos));
n4 = int(fmod(num_puntos*(i+1)+j,num_nodos));
if(j == num_puntos-1) {
n2 = n1-num_puntos+1;
n3 = n4-num_puntos+1;
}
else {
n2 = int(fmod(num_puntos*i+j+1,num_nodos));
n3 = int(fmod(num_puntos*(i+1)+j+1,num_nodos));
}
ind_nodos.push_back(n3);
ind_nodos.push_back(n2);
ind_nodos.push_back(n1);
a1 = 3*(i*num_puntos+j);
if(i == num_anillos-2) {
a1 = 3*i*num_puntos+4*j;
}
a2 = a1+1;
a3 = a1+2;
ind_arcos.push_back(a1);
ind_arcos.push_back(a2);
ind_arcos.push_back(a3);
c = new Triangulo(ind_nodos,ind_arcos);
ind_cara1 = caras->addCara(c);
nodos->addCaraNodo(n1,ind_cara1);
nodos->addCaraNodo(n2,ind_cara1);
nodos->addCaraNodo(n3,ind_cara1);
ind_nodos.clear();
ind_arcos.clear();
ind_nodos.push_back(n4);
ind_nodos.push_back(n3);
ind_nodos.push_back(n1);
a1 = 3*(i*num_puntos+j)+2;
if(i == num_anillos-2) {
a1 = 3*i*num_puntos+4*j+2;
}
a2 = 3*(i+1)*num_puntos+3*j;
if(i == num_anillos-3) {
a2 = 3*(i+1)*num_puntos+4*j;
}
else if(i == num_anillos-2) {
a2 = a1+1;
}
a3 = a1 - 4;
if(i == num_anillos-2) {
if(j==0) {
a3 = a1+4*(num_puntos-1)-1;
}
else {
a3 = a1-5;
}
}
else {
if(j==0) {
a3 = a1+3*(num_puntos-1)-1;
}
}
ind_arcos.push_back(a1);
ind_arcos.push_back(a2);
ind_arcos.push_back(a3);
c = new Triangulo(ind_nodos,ind_arcos);
ind_cara2 = caras->addCara(c);
nodos->addCaraNodo(n1,ind_cara2);
nodos->addCaraNodo(n3,ind_cara2);
nodos->addCaraNodo(n4,ind_cara2);
int ind_cara3 = -1;
if(i != 0) {
ind_cara3 = ind_cara1-(2*num_puntos)+1;
}
a = new Arco(n1,n2,ind_cara1,ind_cara3);
ind_arco = arcos->addArco(a);
nodos->addArcoNodo(n1,ind_arco);
nodos->addArcoNodo(n2,ind_arco);
ind_cara3 = ind_cara1+3;
if(j == num_puntos-1) {
ind_cara3 = ind_cara1-2*(num_puntos-1)+1;
}
a = new Arco(n2,n3,ind_cara1,ind_cara3);
ind_arco = arcos->addArco(a);
nodos->addArcoNodo(n2,ind_arco);
nodos->addArcoNodo(n3,ind_arco);
a = new Arco(n1,n3,ind_cara1,ind_cara2);
ind_arco = arcos->addArco(a);
nodos->addArcoNodo(n1,ind_arco);
nodos->addArcoNodo(n3,ind_arco);
if(i == num_anillos-2) {
if(j == num_puntos-1) {
a = new Arco(int(fmod(n1+num_puntos,num_nodos)),int(fmod(n1+1,num_nodos)),ind_cara2,-1);
ind_arco = arcos->addArco(a);
nodos->addArcoNodo(int(fmod(n1+num_puntos,num_nodos)),ind_arco);
nodos->addArcoNodo(int(fmod(n1+1,num_nodos)),ind_arco);
}
else {
a = new Arco(int(fmod(n1+num_puntos,num_nodos)),int(fmod(n1+num_puntos+1,num_nodos)),ind_cara2,-1);
ind_arco = arcos->addArco(a);
nodos->addArcoNodo(int(fmod(n1+num_puntos,num_nodos)),ind_arco);
nodos->addArcoNodo(int(fmod(n1+num_puntos+1,num_nodos)),ind_arco);
}
}
}
}
Malla *malla = new MallaTriangulos(nodos,arcos,caras);
malla->setConcentracionMax(max_concentracion);
malla->setConcentracionMin(min_concentracion);
malla->setNormales();
fclose(mat);
setlocale(LC_NUMERIC, "");
//Chequeamos consistencia topologica.
int V=malla->getNumNodos();
int E=malla->getNumArcos();
int F=malla->getNumCaras();
cout << "Numero de nodos=" << V << endl;
cout << "Numero de arcos=" << E << endl;
cout << "Numero de caras=" << F << endl;
if (V-E+F==2 || V-E+F==0)
cout << "La malla es consistente. Cumple la formula de Euler: V-E+F=2" << endl;
else
cout << "Atencion, la malla no es consistente. No cumple la formula de Euler: V-E+F=" << V-E+F << " y deberia ser V-E+F=2" << endl;
assert(malla->checkMalla(true) >= 0);
return malla;
}
Punto Arco::getPuntoMedio(Malla *malla) {
assert(malla != 0);
Punto p1 = malla->getNodo(this->getNodo1())->getPunto();
Punto p2 = malla->getNodo(this->getNodo2())->getPunto();
return Punto((p1.getX()+p2.getX())/2,(p1.getY()+p2.getY())/2,(p1.getZ()+p2.getZ())/2);
}
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();
}
}
}
}
void myinit(void); void buttonMouse(int key, int state, int x, int y); void moveMouse(int x, int y); void myReshape(GLsizei w, GLsizei h); void display(void); //Cámaras CamaraPerspectiva canon; CamaraOrtografica cenital, perfil, frontal; //Transformaciones que se aplican a las fotos para situarlas en la ventana Transformacion NO, NE, SO, SE; //Ejes Punto OR = Punto(); Punto EX = Punto(1.0); Punto EY = Punto(0.0,1.0); Punto EZ = Punto(0.0,0.0,1.0); //Tetera Punto sb[NVERT*NVERT]; Vector n[NVERT*NVERT]; Vector tgU[NVERT*NVERT]; Vector tgV[NVERT*NVERT]; bool inalambrico = true; //Movimiento de la camara Punto AT = Punto(4.0, 5.0, 5.0); Punto FR = Punto(0.0, 0.0, 2.0); Punto PE = Punto(2.0, 0.0, 0.0);
Malla* GeneraFromComsol_1::aplicar() {
int n_triangulos = 0, n_cuadrilateros = 0; // cantidad de caras de tres y cuatro lados
ifstream in(archivo.c_str());
char line[MAXLINE];
in.getline(line,MAXLINE);
string cx,cy,cz;
float x,y,z;
int num_puntos, num_caras;
num_puntos=0;
Nodos *nodos = new Nodos();
Nodo *nodo;
while(true) {
in.getline(line,MAXLINE);
stringstream streamin(line);
if (line[0]=='%')
break;
streamin >> x;
streamin >> y;
streamin >> z;
nodo = new Nodo(Punto(x,y,z));
nodos->addNodo(nodo);
num_puntos++;
}
map<pair<int,int>,int> ind_arcos;
map<pair<int,int>,int>::iterator iter1;
map<pair<int,int>,int>::iterator iter2;
vector<int> indice_puntos;
vector<int> indice_arcos;
Arcos *arcos = new Arcos();
Caras *caras = new Caras();
Cara *c;
int indice;
int indices[4], n_lados;
num_caras=0;
while(true) {
indices[3]=-1;
in.getline(line,MAXLINE);
if (in.fail() || line[0]=='%')
break;
stringstream streamin(line);
for(int i=0; i<4; i++)
streamin >> indices[i];
if(indices[3] == -1) {
n_triangulos++;
n_lados = 3;
}
else {
n_cuadrilateros++;
n_lados = 4;
}
//Nota: Por bug en los archivos de entrada, debo invertir el orden para que las normales queden bien.
//for(int i=n_lados-1; i>=0; i--) // por el bug
for(int i=0; i<n_lados; i++) // así debiera ser
indice_puntos.push_back(indices[i]-1);
for(int j=0; j<n_lados; j++) {
int ind1 = indice_puntos[j];
int ind2 = indice_puntos[int(fmod(j+1,n_lados))];
pair<int,int> pr1(ind1,ind2);
pair<int,int> pr2(ind2,ind1);
iter1 = ind_arcos.find(pr1);
iter2 = ind_arcos.find(pr2);
if(iter1 != ind_arcos.end())
indice_arcos.push_back(iter1->second);
else if(iter2 != ind_arcos.end())
indice_arcos.push_back(iter2->second);
else {
indice = arcos->addArco(new Arco(ind1,ind2));
indice_arcos.push_back(indice);
ind_arcos.insert(make_pair(pr1,indice));
nodos->addArcoNodo(ind1,indice);
nodos->addArcoNodo(ind2,indice);
}
}
if(n_lados == 3)
c = new Triangulo(indice_puntos,indice_arcos);
else if(n_lados == 4)
c = new Cuadrilatero(indice_puntos,indice_arcos);
else
c = new Cara(indice_puntos,indice_arcos);
int ind_cara = caras->addCara(c);
num_caras++;
for(int j=0; j<n_lados; j++) {
arcos->setCaraArco(indice_arcos[j],ind_cara);
nodos->addCaraNodo(indice_puntos[j],ind_cara);
}
indice_puntos.clear();
indice_arcos.clear();
}
Malla *malla = 0;
if(n_cuadrilateros == 0)
malla = new MallaTriangulos(nodos,arcos,caras);
else if(n_triangulos == 0)
malla = new MallaCuadrilateros(nodos,arcos,caras);
else
malla = new Malla(nodos,arcos,caras);
malla->setConcentracionTodos(1.0);
malla->setConcentracionMax(1.0);
malla->setConcentracionMin(0.0);
malla->setNormales();
in.close();
//Chequeamos consistencia topologica.
int V=malla->getNumNodos();
int E=malla->getNumArcos();
int F=malla->getNumCaras();
cout << "Numero de nodos=" << V << endl;
cout << "Numero de arcos=" << E << endl;
cout << "Numero de caras=" << F << endl;
if (V-E+F==2 || V-E+F==0)
cout << "La malla es consistente. Cumple la formula de Euler: V-E+F=2" << endl;
else
cout << "Atencion, la malla no es consistente. No cumple la formula de Euler: V-E+F=" << V-E+F << " y deberia ser V-E+F=2" << endl;
assert(malla->checkMalla(true) >= 0);
cout << endl;
return malla;
}
/*
=======================================================================================================================
=======================================================================================================================
*/
FlipFlopD::FlipFlopD(int n1, int x1, int y1) :
FlipFlop(n1, x1, y1)
{
D = Punto(x1, y1 - 15);
}
Esfera::Esfera()
{// Construye la esfera unidad por defecto
centro = Punto();
radio = 1.0f;
}
Punto Ambiental::L(Punto p) { return Punto(0,0,0); }
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;
}
Malla* GeneraCilindro::generaMallaCuadrilateros() {
//Genero la medula.
vector<Punto> medula;
medula.push_back(Punto(0,0,0));
medula.push_back(Punto(0,altura,0));
int num_nodos = num_anillos * num_puntos;
Nodos *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);
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);
}
}
Arco *a;
Arcos *arcos = new Arcos();
Cara *c;
Caras *caras = new Caras();
int ind_cara, ind_arco;
int n1, n2, n3, n4;
vector<int> ind_nodos;
vector<int> ind_arcos;
for(int i=0; i<(num_anillos-1); i++) {
for(int j=0; j<num_puntos; j++) {
ind_nodos.clear();
ind_arcos.clear();
// Orden: n1 n2 n3 n4 <-> SE SO NO NE
n1 = int(fmod(num_puntos*i+j,num_nodos));
n4 = int(fmod(num_puntos*(i+1)+j,num_nodos));
if(j == num_puntos-1) {
n2 = n1-num_puntos+1;
n3 = n4-num_puntos+1;
}
else {
n2 = int(fmod(num_puntos*i+j+1,num_nodos));
n3 = int(fmod(num_puntos*(i+1)+j+1,num_nodos));
}
// Orden inverso para tener normal saliente
ind_nodos.push_back(n4);
ind_nodos.push_back(n3);
ind_nodos.push_back(n2);
ind_nodos.push_back(n1);
if(i == num_anillos-2) {
if(j == 0) {
ind_arcos.push_back(2*(n1-1)+3*num_puntos);
}
else {
ind_arcos.push_back(2*n1+j-2);
}
ind_arcos.push_back(2*n1+j);
ind_arcos.push_back(2*n1+j+1);
ind_arcos.push_back(2*(n1+1)+j);
}
else {
if(j == 0) {
ind_arcos.push_back(2*(n1+num_puntos)-1);
}
else {
ind_arcos.push_back(2*n1-1);
}
ind_arcos.push_back(2*n1);
ind_arcos.push_back(2*n1+1);
if(i == num_anillos-3) {
ind_arcos.push_back(2*n1+2*num_puntos+j);
}
else {
ind_arcos.push_back(2*n1+2*num_puntos);
}
}
c = new Cuadrilatero(ind_nodos,ind_arcos);
ind_cara = caras->addCara(c);
nodos->addCaraNodo(n1,ind_cara);
nodos->addCaraNodo(n2,ind_cara);
nodos->addCaraNodo(n3,ind_cara);
nodos->addCaraNodo(n4,ind_cara);
int ind_cara2 = -1;
if(i != 0) {
ind_cara2 = ind_cara-num_puntos;
}
a = new Arco(n1,n2,ind_cara,ind_cara2);
ind_arco = arcos->addArco(a);
nodos->addArcoNodo(n1,ind_arco);
nodos->addArcoNodo(n2,ind_arco);
ind_cara2 = ind_cara+1;
if(j == num_puntos-1) {
ind_cara2 = ind_cara-num_puntos+1;
}
a = new Arco(n2,n3,ind_cara,ind_cara2);
ind_arco = arcos->addArco(a);
nodos->addArcoNodo(n2,ind_arco);
nodos->addArcoNodo(n3,ind_arco);
if(i == num_anillos-2) {
if(j == num_puntos-1) {
a = new Arco(int(fmod(n1+num_puntos,num_nodos)),int(fmod(n1+1,num_nodos)),ind_cara,-1);
ind_arco = arcos->addArco(a);
nodos->addArcoNodo(int(fmod(n1+num_puntos,num_nodos)),ind_arco);
nodos->addArcoNodo(int(fmod(n1+1,num_nodos)),ind_arco);
}
else {
a = new Arco(int(fmod(n1+num_puntos,num_nodos)),int(fmod(n1+num_puntos+1,num_nodos)),ind_cara,-1);
ind_arco = arcos->addArco(a);
nodos->addArcoNodo(int(fmod(n1+num_puntos,num_nodos)),ind_arco);
nodos->addArcoNodo(int(fmod(n1+num_puntos+1,num_nodos)),ind_arco);
}
}
}
}
Malla *malla = new MallaCuadrilateros(nodos,arcos,caras);
malla->setMedula(medula);
malla->setConcentracionMax(1.0);
malla->setConcentracionMin(0.0);
assert(malla->checkMalla(true) >= 0);
return malla;
}
void crear_escena(void) {
Esfera *amarilla, *blanca, *roja, *verde, *azul;
float radio = 0.59673710213f;
// Creamos la escena
if (escena==NULL)
escena = new Escena();
//Esfera
Esfera *esfera = new Esfera(Punto(0,0.1,-2), 0.8);
esfera->setColor(Color(1,0,0), Color(1,1,1), 0.3, 0.3, 0.7, 40);
escena->add(esfera);
//Caja suelo
Transformacion t1;
t1.translation(Real4(0.0, -1.0, -1.5));
t1.scale(2, 0.1, 2);
Caja *cajasuelo = new Caja(t1);
cajasuelo->setColor(Color(1,1,1), Color::BLANCO, 0.1, 0.3, 0.9, 100);
escena->add(cajasuelo);
//Caja cubo
Transformacion t2;
t2.translation(Real4(-1.0, -0.3, -0.3));
t2.rotation(60, Vector(1,1,1));
t2.scale(0.5, 0.5, 0.5);
Caja *cajacubo = new Caja(t2);
cajacubo->setColor(Color(0,1,0), Color::BLANCO, 0.1, 0.8, 0.1, 1);
escena->add(cajacubo);
// Esfera blanca (detrás)
/*blanca = new Esfera(Punto(0.0f, 0.0f, -2.0f), radio);
blanca->setColor(Color::BLANCO);
escena->add(blanca);*/
// Esfera amarilla (NO)
/*amarilla = new Esfera(Punto(-radio, radio,0.0f),radio);
amarilla->setColor(Color::VERDE+Color::ROJO);
escena->add(amarilla);*/
// Esfera roja (SO)
/*roja = new Esfera(Punto(-radio,-radio,0.0f), radio);
roja->setColor(Color::ROJO);
escena->add(roja);
// Esfera azul (SE)
/*azul = new Esfera(Punto(radio, -radio,0.0f), radio);
azul->setColor(Color::AZUL);
escena->add(azul);/*
// Esfera verde (NE)
/*verde = new Esfera(Punto(radio, radio, 0.0f), radio);
verde->setColor(Color::VERDE);
escena->add(verde);*/
/*Transformacion t1;
//t1.translation(Real4(2,2,2,0));
t1.rotation(30, Vector(0,1,0));
t1.rotation(-15, Vector(1,0,0));
t1.scale(0.5, 0.4, 0.3);
Caja *cajaverde = new Caja(t1);
cajaverde->setColor(Color::VERDE);
escena->add(cajaverde);*/
//escena->add(amarilla);
/*for(int i=0;i<6;i++){
for(int j=0;j<4;j++){
printf("%.2f %.2f ", cajaverde->caras[i].vertices[j].x(), cajaverde->caras[i].vertices[j].y());
}
printf("\n");
}*/
}
//This returns the angle between two vectors
float Angle(CVector3 vVector1, CVector3 vVector2)
{
return acosf(Punto(vVector1, vVector2));
}
Caja::Caja(Transformacion T)
{
//ToDo: Implementar
cara.clear();
ncaras = 0;
// Puntos por defecto - Altura de la caja: 2
Punto puntos[24]= {
// Cara 1 - Normal hacia +x
Punto( 1, 1,-1), Punto( 1, 1, 1), Punto( 1,-1, 1), Punto( 1,-1,-1),
// Cara 2 - Normal hacia +y
Punto(-1, 1,-1), Punto(-1, 1, 1), Punto( 1, 1, 1), Punto( 1, 1,-1),
// Cara 3 - Normal hacia +z
Punto(-1, 1, 1), Punto(-1,-1, 1), Punto( 1,-1, 1), Punto( 1, 1, 1),
// Cara 4 - Normal hacia -x
Punto(-1, 1,-1), Punto(-1,-1,-1), Punto(-1,-1, 1), Punto(-1, 1, 1),
// Cara 5 - Normal hacia -y
Punto(-1,-1,-1), Punto( 1,-1,-1), Punto( 1,-1, 1), Punto(-1,-1, 1),
// Cara 6 - Normal hacia -z
Punto(-1,-1,-1), Punto(-1, 1,-1), Punto( 1, 1,-1), Punto( 1,-1,-1)
};
for(int i=0; i<6; i++){
Punto caras[4];
for(int j=0; j<4; j++)
caras[j] = puntos[j+i*4].transform(T);
Poligono *c = new Poligono(4, caras);
cara.push_back(c);
ncaras++;
}
}
