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);
}
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;
}
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);
}
}
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;
}
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));
}
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;
}
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));
}
}
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;
}
