示例#1
0
    void Start()
    {
        on = false;

        // El Text donde se escriben los valores de las variables del punto
        textoInformacion = GameObject.FindWithTag("TextoInformacion").GetComponent <Text>();

        // El fondo donde se escriben los valores de las variables del punto
        fondoInformacion = GameObject.FindWithTag("FondoInformacion").GetComponent <Image>();

        // El objetoPulsable del botonModo3D
        objetoPulsableModo3D = GameObject.FindWithTag("BotonModo3D").GetComponent <ObjetoPulsable>();

        // ControlGraficos de la escena
        controlGraficos = GameObject.FindWithTag("ControlGraficos").GetComponent <ControlGraficos>();

        // El script EsferaDatos del objeto
        esferaDatos = GetComponent <EsferaDatos>();
    }
    // Función para trazar el gráfico, tanto 2D como 3D
    public void TrazarGrafico()
    {
        // Se destruye el anterior gráfico, destruyendo soportePuntos y lineRenderer, y se vuelve a instanciar
        //Destroy(soportePuntos);
        soportePuntos = Instantiate(
            SoportePuntos,
            new Vector3(0, 0, 0),
            Quaternion.identity);

        // Se destruye la anterior línea
        //Destroy(lineaGrafico);
        lineaGrafico = Instantiate(
            PrefabLinea,
            new Vector3(0, 0, 0),
            Quaternion.identity);


        // Se accede al Component LineRenderer de lineaGrafico para cambiar valores de ancho de inicio y final
        lineaGrafico.GetComponent <LineRenderer>().startWidth = inicioLineaGrafico;
        lineaGrafico.GetComponent <LineRenderer>().endWidth   = finalLineaGrafico;

        // Se establece el color de lineaGrafico
        lineaGrafico.GetComponent <LineRenderer>().startColor = DimeColor(columnaY);
        lineaGrafico.GetComponent <LineRenderer>().endColor   = DimeColor(columnaY);

        // Resultado funcion leer del LectorCSV en listaPuntos con argumento archivoInput. Se manda false porque se quiere leer números
        listaPuntos = LectorCSV.Leer(archivoInput);

        // Lista de cadenas, con las keys (nombres de las columnas)
        List <string> listaColumnas = new List <string>(listaPuntos[1].Keys);

        // Asignacion nombres columnas desde listaColumnas a variables nombre
        nombreX = listaColumnas[columnaX];
        nombreY = listaColumnas[columnaY];
        nombreZ = listaColumnas[columnaZ];

        // Obtención máximos en cada eje
        float xMax = EncontrarValorMaximo(nombreX);
        float yMax = EncontrarValorMaximo(nombreY);
        float zMax = EncontrarValorMaximo(nombreZ);

        // Obtención de mínimos en cada eje
        float xMin = EncontrarValorMinimo(nombreX);
        float yMin = EncontrarValorMinimo(nombreY);
        float zMin = EncontrarValorMinimo(nombreZ);

        float x;
        float y;
        float z;

        // El número de vértices del lineRenderer es el número de puntos en listaPuntos
        lineaGrafico.GetComponent <LineRenderer>().positionCount = listaPuntos.Count;

        // Loop en listaPuntos
        for (var i = 0; i < listaPuntos.Count; i++) // listaPuntos.Count devuelve el número de filas en la lista
        {
            // Obtener valor en listaPuntos en la iesima fila de la columna con nombre determinado, normalizado
            if (xMax != xMin)
            {
                x =
                    (System.Convert.ToSingle(listaPuntos[i][nombreX]) - xMin) / (xMax - xMin) + xInicial / escalaGrafico;
            }

            else
            {
                x = System.Convert.ToSingle(listaPuntos[i][nombreX]) + xInicial / escalaGrafico;
            }

            if (yMax != yMin)
            {
                y =
                    (System.Convert.ToSingle(listaPuntos[i][nombreY]) - yMin) / (yMax - yMin) + yInicial / escalaGrafico;
            }

            else
            {
                y = System.Convert.ToSingle(listaPuntos[i][nombreY]) + yInicial / escalaGrafico;
            }


            // Si el modo 2D está desactivado se da valor a z de la forma habitual
            if (modo2D == false)
            {
                if (zMax != zMin)
                {
                    z =
                        (System.Convert.ToSingle(listaPuntos[i][nombreZ]) - zMin) / (zMax - zMin) + zInicial / escalaGrafico;
                }

                else
                {
                    z = System.Convert.ToSingle(listaPuntos[i][nombreZ]) + zInicial / escalaGrafico;
                }
            }

            // Si el modo 2D está activado todos los puntos tienen el mismo valor en z
            else
            {
                // Se multiplica el valor por escalaGrafico al instanciar posteriormente
                z = zInicial / escalaGrafico;

                // Se añade punto al lineRenderer
                lineaGrafico.GetComponent <LineRenderer>().SetPosition(i, new Vector3(x, y, z) * escalaGrafico);
            }

            // Se instancia un PrefabPunto
            GameObject puntoDatos = Instantiate(
                PrefabPunto,
                new Vector3(x, y, z) * escalaGrafico,
                Quaternion.identity);

            EsferaDatos esferaDatos = puntoDatos.GetComponent <EsferaDatos>();

            // Se hace puntoDatos derivada de SoportePuntos
            puntoDatos.transform.parent = soportePuntos.transform;

            // Asignacion valor a nombrePuntoDatos
            string nombrePuntoDatos =
                listaPuntos[i][nombreX] + " "
                + listaPuntos[i][nombreY] + " "
                + listaPuntos[i][nombreZ];

            // Se asigna nombre coherente al prefab
            puntoDatos.transform.name = nombrePuntoDatos;

            // Se guardan los valores del punto
            Vector3 valores = new Vector3(
                System.Convert.ToSingle(listaPuntos[i][nombreX]),
                System.Convert.ToSingle(listaPuntos[i][nombreY]),
                System.Convert.ToSingle(listaPuntos[i][nombreZ])
                );
            esferaDatos.GuardarValores(valores);
            esferaDatos.GuardarVariables(nombreX, nombreY, nombreZ);

            // Define un color RGBA para el punto
            if (modo2D == true)
            {
                // En modo 2D los puntos tienen el color de la línea
                puntoDatos.GetComponent <Renderer>().material.color = DimeColor(columnaY);
            }

            else
            {
                // Interpolación de colores para cada esfera
                pesoX = x / (x + y + z);
                pesoY = y / (x + y + z);
                pesoZ = z / (x + y + z);


                puntoDatos.GetComponent <Renderer>().material.color =
                    new Color(
                        DimeColor(columnaX).r *pesoX + DimeColor(columnaY).r *pesoY + DimeColor(columnaZ).r *pesoZ,
                        DimeColor(columnaX).g *pesoX + DimeColor(columnaY).g *pesoY + DimeColor(columnaZ).g *pesoZ,
                        DimeColor(columnaX).b *pesoX + DimeColor(columnaY).b *pesoY + DimeColor(columnaZ).b *pesoZ,
                        1.0f);
            }
        }

        // Si se está en modo 3D, se deben instanciar los ejes y girar todo 90 grados
        if (modo2D == false)
        {
            InstanciaEjes();

            conoEjeX.transform.parent = lineaGraficoX.transform;
            conoEjeY.transform.parent = lineaGraficoY.transform;
            conoEjeZ.transform.parent = lineaGraficoZ.transform;

            // Se gira soportePuntos, los ejes y las flechas para que apunten de cara
            soportePuntos.transform.rotation = Quaternion.Euler(0, 90, 0);
            lineaGraficoX.transform.rotation = Quaternion.Euler(0, 90, 0);
            lineaGraficoY.transform.rotation = Quaternion.Euler(0, 90, 0);
            lineaGraficoZ.transform.rotation = Quaternion.Euler(0, 90, 0);

            // Se giran los conos para que apunten en la dirección adecuada
            conoEjeX.transform.rotation = Quaternion.Euler(-90, 0, 0);
            conoEjeY.transform.rotation = Quaternion.Euler(0, 0, 0);
            conoEjeZ.transform.rotation = Quaternion.Euler(0, 0, -90);
        }
    }