Exemplo n.º 1
0
        private void Button1_Click(object sender, EventArgs e)
        {
            DataGridView  dgv = new DataGridView();
            AtributosForm frm = new AtributosForm("", dgv, -1, modificaciones, true);

            if (frm.ShowDialog() == DialogResult.OK)
            {
                editando = true;
                //Guardar modificación del atributo
                atributo.Add(frm.atributo);
                string[] spliter     = atributo[atributo.Count - 1].Split(' ');
                string[] newcabecera = new string[3];
                newcabecera[0] = spliter[0];
                newcabecera[1] = spliter[1];
                newcabecera[2] = atributo[atributo.Count - 1].Substring((spliter[0].Length + spliter[1].Length) + 2);
                cabecera.Add(newcabecera);
                modificaciones = frm.modificado;

                //prueba de almacenamiento de cambios
                atributoscomboBox.Items.Add(newcabecera[0]);
                //this.dataGridView1.Columns.Add(newcabecera[0], newcabecera[0]);
                DataTable dt = new DataTable();

                for (int i = 0; i < cabecera.Count; i++)
                {
                    dt.Columns.Add(new DataColumn(cabecera[i][0]));
                }

                //Leemos los datos
                for (int r = 0; r < this.dataGridView1.Rows.Count - 1; r++)
                {
                    DataGridViewRow newrow = this.dataGridView1.Rows[r];
                    DataRow         dr     = dt.NewRow();
                    for (int j = 0; j < cabecera.Count; j++)
                    {
                        //Validar missingvalue
                        if (j == cabecera.Count - 1)
                        {
                            if (faltante.Count > 0)
                            {
                                dr[j] = faltante[0];
                            }
                            else
                            {
                                dr[j] = "";
                            }
                        }
                        else
                        {
                            dr[j] = newrow.Cells[j].Value;
                        }
                    }
                    dt.Rows.Add(dr);
                }
                this.dataGridView1.DataSource = dt;
                celdaString = "";

                // Aqui la funcion esta hecha pero falta ver como llamarla en el mismo form del edit, aunque no jale nada
                //delete_atributo(1);

                //Actualizamos faltantes

                for (int i = 0; i < this.dataGridView1.Rows.Count - 1; i++)
                {
                    faltantes++;
                }
                label5.Text = "Valores faltantes\n" + faltantes;
                label6.Text = "Proporción de valores faltantes\n" + ((faltantes * 100) / ((nInstancia - 1) * (cabecera.Count - 1))) + "%";
                EvalRegex();
                for (int i = 0; i < this.dataGridView1.Rows.Count; i++)
                {
                    DataGridViewRow rowaux = this.dataGridView1.Rows[i];
                    //rowaux.Cells[cabecera.Count - 1].Style.BackColor = Color.Red;
                }
                editando = false;
            }
        }
Exemplo n.º 2
0
        private DataTable LeerDATA(DataTable dt)
        {
            string[] lines = File.ReadAllLines(filepath);
            if (lines.Length > 0)
            {
                int x = 0;
                int y = 0;
                nInstancia = 1;
                bool df = false;
                // Leemos la info general
                string[] copia = new string[3];
                copia[0] = "Instancia";
                cabecera.Add(copia);
                foreach (string lin in File.ReadAllLines(filepath))
                {
                    //leer los datos y situarlos en la tabla
                    if (df == true)
                    {
                        string instance = nInstancia.ToString() + ',' + lin;
                        nInstancia++;
                        string[] dataWords   = instance.Split(',');
                        DataRow  dr          = dt.NewRow();
                        int      columnIndex = 0;


                        foreach (string[] headerWord in cabecera)
                        {
                            /**/
                            foreach (string aux in faltante)
                            {
                                if (dataWords[columnIndex] == aux)
                                {
                                    faltantes++;
                                }
                            }
                            dr[headerWord[0]] = dataWords[columnIndex++];
                        }
                        dt.Rows.Add(dr);
                    }
                    label3.Text = "Cantidad de instancias\n" + (nInstancia - 1);

                    //Leer información general
                    if (lin.Substring(0, 3) == "%% ")
                    {
                        textBox2.Text += lin.Substring(3) + '\n';
                    }

                    //Leer nombre del conjunto de datos
                    if (lin.Substring(0, 5) == "@rela")
                    {
                        textBox1.Text = lin.Substring(10);
                    }

                    //Leer atributos, y guardarlos en una lista de strings (toda la
                    //linea correspondiente al dato
                    if (lin.Substring(0, 5) == "@attr")
                    {
                        atributo.Add(lin.Substring(11));

                        //Crear cabecera

                        int a = 0;
                        for (int i = 0; i < atributo[x].Length; i++)
                        {
                            if (atributo[x][i] != ' ')
                            {
                                a++;
                            }
                            else
                            {
                                break;
                            }
                        }
                        copia    = new string[3];
                        copia[0] = atributo[x].Substring(0, a);
                        string subSatrib = atributo[x].Substring(a + 1);
                        int    b         = 0;
                        for (int i = 0; i < subSatrib.Length; i++)
                        {
                            if (subSatrib[i] != ' ')
                            {
                                b++;
                            }
                            else
                            {
                                break;
                            }
                        }
                        copia[1] = subSatrib.Substring(0, b);
                        copia[2] = subSatrib.Substring(b + 1);
                        cabecera.Add(copia);

                        x++;
                    }
                    label4.Text = "Cantidad de atributos\n" + (cabecera.Count() - 1);

                    //leer valores faltantes y guardarlos en una lista de faltantes
                    if (lin.Substring(0, 5) == "@miss")
                    {
                        faltante.Add(lin.Substring(14));
                        y++;
                    }

                    //localiza la línea @data para a partir de esta leer los datos
                    if (lin.Substring(0, 5) == "@data")
                    {
                        df = true;
                        //falta leer cabecera con atributo list
                        foreach (string[] headerWord in cabecera)
                        {
                            dt.Columns.Add(new DataColumn(headerWord[0]));
                            if (headerWord[0] != "Instancia")
                            {
                                atributoscomboBox.Items.Add(headerWord[0]);
                            }
                        }
                    }
                }
                label5.Text = "Valores faltantes\n" + faltantes;
                label6.Text = "Proporción de valores faltantes\n" + ((faltantes * 100) / ((nInstancia - 1) * (cabecera.Count() - 1))) + "%";
            }
            return(dt);
        }

        public void GuardarToolStripMenuItem_Click(object sender, EventArgs e)
        {
            bool flag = false;

            if (filepath.Contains(".csv"))
            {
                flag = SaveCSV();
            }
            else if (filepath.Contains(".data"))
            {
                flag = SaveDATA();
            }
            if (flag)
            {
                MessageBox.Show("El archivo ha sido guardado correctamente", "Aviso");
                modificaciones = false;
            }
        }

        private bool SaveCSV()
        {
            try
            {
                System.IO.StreamWriter csvFileWriter = new StreamWriter(filepath, false);

                string columnHeaderText = "";

                int countColumn = dataGridView1.ColumnCount - 1;
                //Guardamos el header en un string
                if (countColumn >= 0)
                {
                    columnHeaderText = dataGridView1.Columns[1].HeaderText;
                }

                for (int i = 2; i <= countColumn; i++)
                {
                    columnHeaderText = columnHeaderText + ',' + dataGridView1.Columns[i].HeaderText;
                }

                //Guarda el string del header en el csv
                csvFileWriter.WriteLine(columnHeaderText);

                //Leer los datos
                foreach (DataGridViewRow dataRowObject in dataGridView1.Rows)
                {
                    if (!dataRowObject.IsNewRow)
                    {
                        string dataFromGrid = "";

                        //Para cada fila genera la cadena con el formato
                        for (int i = 1; i <= countColumn; i++)
                        {
                            if (i != countColumn)
                            {
                                dataFromGrid += dataRowObject.Cells[i].Value.ToString() + ',';
                            }
                            else if (i == countColumn)
                            {
                                dataFromGrid += dataRowObject.Cells[i].Value.ToString();
                            }
                        }
                        //Escribe la fila al archivo
                        csvFileWriter.WriteLine(dataFromGrid);
                    }
                }
                csvFileWriter.Flush();
                csvFileWriter.Close();
            }
            catch (Exception exceptionObject)
            {
                MessageBox.Show(exceptionObject.ToString());
                return(false);
            }
            return(true);
        }

        private bool SaveDATA()
        {
            try
            {
                System.IO.StreamWriter csvFileWriter = new StreamWriter(filepath, false);

                string[] rowInfo = textBox2.Text.Split('\n');
                foreach (string strInfo in rowInfo)
                {
                    if (strInfo != "")
                    {
                        csvFileWriter.WriteLine("%% " + strInfo);
                    }
                }
                if (textBox1.Text != "")
                {
                    csvFileWriter.WriteLine("@relation " + textBox1.Text);
                }

                int countColumn = dataGridView1.ColumnCount - 1;
                //Guardamos el header
                for (int i = 1; i <= countColumn; i++)
                {
                    if ((cabecera[i][1].Length > 0) || (cabecera[i][2].Length > 0))
                    {
                        csvFileWriter.WriteLine("@attribute " + cabecera[i][0] + ' ' + cabecera[i][1] + ' ' + cabecera[i][2]);
                    }
                    else
                    {
                        csvFileWriter.WriteLine("@attribute " + dataGridView1.Columns[i].HeaderText + " unknown ");
                    }
                }

                //Guardar missingvalues
                int miss_cont = 0;
                if (faltante.Count > 0)
                {
                    foreach (string miss in faltante)
                    {
                        csvFileWriter.WriteLine("@missingValue " + faltante[miss_cont]);
                        miss_cont++;
                    }
                }

                //Guardar los datos
                csvFileWriter.WriteLine("@data");
                foreach (DataGridViewRow dataRowObject in dataGridView1.Rows)
                {
                    if (!dataRowObject.IsNewRow)
                    {
                        string dataFromGrid = "";

                        //Para cada fila genera la cadena con el formato
                        for (int i = 1; i <= countColumn; i++)
                        {
                            if (i != countColumn)
                            {
                                dataFromGrid += dataRowObject.Cells[i].Value.ToString() + ',';
                            }
                            else if (i == countColumn)
                            {
                                dataFromGrid += dataRowObject.Cells[i].Value.ToString();
                            }
                        }
                        //Escribe la fila al archivo
                        csvFileWriter.WriteLine(dataFromGrid);
                    }
                }
                csvFileWriter.Flush();
                csvFileWriter.Close();
            }
            catch (Exception exceptionObject)
            {
                MessageBox.Show(exceptionObject.ToString());
                return(false);
            }
            return(true);
        }

        private void GuardarComoToolStripMenuItem_Click(object sender, EventArgs e)
        {
            bool flag = false;

            saveFileDialog1.Title            = "Abrir archivo";
            saveFileDialog1.Filter           = "Archivos CSV (*.csv)|*.csv|Archivos DATA(*.data)|*.data";
            saveFileDialog1.FileName         = "";
            saveFileDialog1.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments) + "\\dev\\DMApp\\files";
            if (saveFileDialog1.ShowDialog() == DialogResult.OK)
            {
                filepath    = saveFileDialog1.FileName;
                label1.Text = "Información general\n";
                label2.Text = "Nombre del conjunto de datos\n";
                if (filepath.Contains(".csv"))
                {
                    flag = SaveCSV();
                }
                else if (filepath.Contains(".data"))
                {
                    flag = SaveDATA();
                }
                if (flag)
                {
                    this.Text = "DMApp - " + Path.GetFileName(filepath);
                    MessageBox.Show("El archivo ha sido guardado correctamente", "Aviso");
                }
            }
        }

        private void Form1_Load(object sender, EventArgs e)
        {
        }

        private void EditarAtributosToolStripMenuItem_Click(object sender, EventArgs e)
        {
        }

        private void AtributoscomboBox_SelectedIndexChanged(object sender, EventArgs e)
        {
            string seleccion;

            seleccion = Convert.ToString(atributoscomboBox.SelectedItem);
            indexCB   = atributoscomboBox.SelectedIndex;
            string nuevo = " ";
            string old   = "";

            string copia;

            if (seleccion != " ")
            {
                int o = 0;

                /*Comparación de atributo seleccionado con la lista de atributos
                 * previamente tuve que hacer que los csv tambien tuvieran una lista
                 * de atributos, en ellos cada elemento solamente tiene el nombre del atributo
                 * La comparación toma el nombre del atributo y lo compara cada elemento de la
                 * lista de atributos hasta el primer espacio (para que compare con csv y data)
                 *
                 */
                o = 0;
                foreach (string seleccionado in atributo)
                {
                    //encuentra el nombre
                    int a = 0;
                    for (int i = 0; i < seleccionado.Length; i++)
                    {
                        if (seleccionado[i] != ' ')
                        {
                            a++;
                        }
                        else
                        {
                            break;
                        }
                    }

                    //lo compara con el seleccionado
                    copia = seleccionado.Substring(0, a);
                    if (copia == seleccion)
                    {
                        old = copia;
                        DataGridView  dgv = dataGridView1;
                        AtributosForm frm = new AtributosForm(seleccionado, dgv, indexCB, modificaciones, false);
                        if (frm.ShowDialog() == DialogResult.OK)
                        {
                            nuevo          = frm.atributo;
                            modificaciones = frm.modificado;
                            /**/
                            break;
                            /**/
                        }
                        else
                        {
                            modificaciones = frm.modificado;
                            dataGridView1  = frm.dgv;
                            indexCB        = frm.index;
                            cabecera.RemoveAt(frm.index2);
                            atributo.RemoveAt(frm.index2 - 1);
                            atributoscomboBox.Items.RemoveAt(frm.index);

                            return;
                        }
                        //"nuevo" corresponde a el nuevo atributo modificado en el form de atributos
                    }
                    //o es usado para contar en que lugar se encuetra ese atributo
                    o++;
                }

                if (modificaciones)
                {
                    int auxo = o;
                    //Guardar modificación del atributo
                    if (filepath.Contains(".data"))
                    {
                        auxo++;
                    }
                    atributo[o] = nuevo;
                    string[] spliter = atributo[o].Split(' ');
                    cabecera[auxo][0] = spliter[0];
                    cabecera[auxo][1] = spliter[1];
                    cabecera[auxo][2] = atributo[o].Substring((spliter[0].Length + spliter[1].Length) + 2);


                    //prueba de almacenamiento de cambios
                    atributoscomboBox.Items.RemoveAt(indexCB);
                    atributoscomboBox.Items.Insert(indexCB, cabecera[auxo][0]);

                    Update_Grid_Header(old, cabecera[auxo][0]);
                    // Aqui la funcion esta hecha pero falta ver como llamarla en el mismo form del edit, aunque no jale nada
                    //delete_atributo(1);
                }
            }
        }