C++ Punto::getZ方法代码示例

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