package baseconocimiento;
import baseconocimiento.utilidades.Limite;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.ResourceBundle;
import java.util.logging.Level;
import java.util.logging.Logger;
import jxl.Cell;
import jxl.CellType;
import jxl.Sheet;
import jxl.Workbook;
import jxl.read.biff.BiffException;
import jxl.write.WritableCell;
import jxl.write.WritableSheet;
import jxl.write.WritableWorkbook;
import jxl.write.WriteException;
import jxl.write.Number;
import modelo.Barrio;
/**
*
* @author UTPL
*/
public class ArchivoExcelBaseConocimiento {
/**
* String nombreArchivo: Nombre de Archivo de Excel de donde proviene los datos de la
* Base de Conocimiento
*/
private String nombreArchivo;
/**
* String hojaNombresPuntos: Nombre de la hoja donde se encuentra los nombres de los puntos
*/
private String hojaNombresPuntos;
/**
* String hojaCoordenadasPuntos: Nombre de la hoja donde se encuentra las coordenadas
*/
private String hojaCoordenadasPuntos;
/**
*String hojaHeuristica: Nombre de la hoja donde se encuentra la heuristica
*/
private String hojaHeuristica;
/**
* String hojaReglas: Nombre de la hoja donde se encuentra las Reglas
*/
private String hojaReglas;
/**
*String hojaConfiguraciones: Nombre de la hoja donde se encuentra las configuraciones para ejecutar normalmene el software
*/
private String hojaConfiguraciones;
/**
* int Constante para el elemento Nombre de Puntos
*/
private static int NOMBRESPUNTOS = 0;
/**
* int Constante para el elemento Coordenadas de Puntos
*/
private static int COORDENADASPUNTOS = 1;
/**
* int Constante para el elemento Heuristica
*/
private static int HEURISTICA = 2;
/**
* int Constante para el elemento Heuristica
*/
private static int REGLAS = 3;
/**
* Archivo de entrada excel para la base de conocimiento
*/
private File ArchivoExcelEntrada;
/**
* Elemento de trabajo de excel
*/
private Workbook libroTrabajo;
/**
* Archivo de salida excel para guardar las configluraciones de la base de conocimiento
*/
private File ArchivoExcelSalida;
/**
* Elemento de trabajo de excel, en el cual se cargan todas las hojas del Excel
*/
private WritableWorkbook libroTrabajoSalida;
/**
* boolean que nos sirve para saber si esta abierto o cerrado el archivo
*/
private boolean abiertoCerradoLibroEntrada;
/**
* boolean que nos sirve para saber si esta abierto o cerrado el archivo
*/
private boolean abiertoCerradoLibroSalida;
/**
*
* @return String [] Un arreglo que contiene los nombres de los puntos de los barrios.
*/
public String[][] leerNombrePuntos() {
if (!this.abiertoCerradoLibroEntrada) {
//esta cerrado entonces abrimos el archivo
System.out.println("ARCHIVO ENTRADA: CERRADO-ABIERTO");
abrirArchivoEntrada();
} else {
System.out.println("ARCHIVO ENTRADA: ABIERTO-CERRADO");
}
Limite limite = leerLimites(ArchivoExcelBaseConocimiento.NOMBRESPUNTOS);
String[][] reglas = new String[limite.getFilas()][limite.getColumnas()];
System.out.println("Nombre Puntos");
for (int i = 0; i < limite.getFilas(); i++) {
for (int j = 0; j < limite.getColumnas(); j++) {
Sheet sheet = libroTrabajo.getSheet(this.hojaNombresPuntos);
//recordar que primero son las columnas y luego filas
Cell a1 = sheet.getCell(j + 1, i + 1);
String stringfilas = a1.getContents();
if (a1.getType() == CellType.EMPTY) {
stringfilas = "-";
}
reglas[i][j] = stringfilas;
System.out.print("[" + i + "][" + j + "]= " + stringfilas + "\t");
}
System.out.println("");
}
return reglas;
}
/**
*
* @return String [] Un arreglo que contiene las coordenadas de los barrios.
*/
public String[][] leerCoordenadasPuntos() {
if (!this.abiertoCerradoLibroEntrada) {
//esta cerrado entonces abrimos el archivo
System.out.println("ARCHIVO ENTRADA: CERRADO-ABIERTO");
abrirArchivoEntrada();
} else {
System.out.println("ARCHIVO ENTRADA: ABIERTO-CERRADO");
}
Limite limite = leerLimites(ArchivoExcelBaseConocimiento.COORDENADASPUNTOS);
String[][] coordenadas = new String[limite.getFilas()][limite.getColumnas()];
System.out.println("Coordenadas");
for (int i = 0; i < limite.getFilas(); i++) {
for (int j = 0; j < limite.getColumnas(); j++) {
Sheet sheet = libroTrabajo.getSheet(this.hojaCoordenadasPuntos);
//recordar que primero son las columnas y luego filas
Cell a1 = sheet.getCell(j + 1, i + 1);
String stringfilas = a1.getContents();
if (a1.getType() == CellType.EMPTY) {
stringfilas = "-";
}
coordenadas[i][j] = stringfilas;
System.out.print("[" + i + "][" + j + "]= " + stringfilas + "\t");
}
System.out.println("");
}
return coordenadas;
}
/**
*
* @return String [] Un arreglo que contiene la heuristica del problema.
*/
public String[][] leerHeuristicaDLRPuntos() {
if (!this.abiertoCerradoLibroEntrada) {
//esta cerrado entonces abrimos el archivo
System.out.println("ARCHIVO ENTRADA: CERRADO-ABIERTO");
abrirArchivoEntrada();
} else {
System.out.println("ARCHIVO ENTRADA: ABIERTO-CERRADO");
}
Limite limite = leerLimites(ArchivoExcelBaseConocimiento.HEURISTICA);
String[][] reglas = new String[limite.getFilas()][limite.getColumnas()];
System.out.println("HEURISTICAS");
for (int i = 0; i < limite.getFilas(); i++) {
for (int j = 0; j < limite.getColumnas(); j++) {
Sheet sheet = libroTrabajo.getSheet(this.hojaHeuristica);
//recordar que primero son las columnas y luego filas
Cell a1 = sheet.getCell(j + 1, i + 1);
String stringfilas = a1.getContents();
if (a1.getType() == CellType.EMPTY) {
stringfilas = "-";
}
reglas[i][j] = stringfilas;
System.out.print("[" + i + "][" + j + "]= " + stringfilas + "\t");
}
System.out.println("");
}
return reglas;
}
/**
*
* @return String [] Un arreglo que contiene las reglas de la base del conocimiento.
*/
public String[][] leerReglas() {
if (!this.abiertoCerradoLibroEntrada) {
//esta cerrado entonces abrimos el archivo
System.out.println("ARCHIVO ENTRADA: CERRADO-ABIERTO");
abrirArchivoEntrada();
} else {
System.out.println("ARCHIVO ENTRADA: ABIERTO-CERRADO");
}
Limite limite = leerLimites(ArchivoExcelBaseConocimiento.REGLAS);
String[][] reglas = new String[limite.getFilas()][limite.getColumnas()];
System.out.println("REGLAS");
for (int i = 0; i < limite.getFilas(); i++) {
for (int j = 0; j < limite.getColumnas(); j++) {
Sheet sheet = libroTrabajo.getSheet(this.hojaReglas);
//recordar que primero son las columnas y luego filas
Cell a1 = sheet.getCell(j + 1, i + 1);
String stringfilas = a1.getContents();
if (a1.getType() == CellType.EMPTY) {
stringfilas = "-";
}
reglas[i][j] = stringfilas;
System.out.print("[" + i + "][" + j + "]= " + stringfilas + "\t");
}
System.out.println("");
}
return reglas;
}
public ArrayList<Barrio> leerBarrios() {
ArrayList<Barrio> barrios = new ArrayList<Barrio>();
String[][] stringCoordenadas = leerCoordenadasPuntos();
String[][] stringNombres = leerNombrePuntos();
int contador = 0;
//creamos todos los barrios en base al numero de nombres de barrios
for (String[] stringN : stringNombres) {
barrios.add(new Barrio(Integer.parseInt(stringN[0]), stringN[1], Double.parseDouble(stringCoordenadas[contador][0]), Double.parseDouble(stringCoordenadas[contador][1])));
contador++;
}
return barrios;
}
public boolean guardarHeuristica(int coordenadaX, int coordenadaY) {
Limite limiteHeuristica = leerLimites(ArchivoExcelBaseConocimiento.HEURISTICA);
try {
if (!this.abiertoCerradoLibroEntrada) {
//esta cerrado entonces abrimos el archivo
System.out.println("Punto 1");
System.out.println("ARCHIVO ENTRADA: CERRADO-ABIERTO");
abrirArchivoEntrada();
} else {
System.out.println("Punto 2");
System.out.println("ARCHIVO ENTRADA: ABIERTO-CERRADO");
}
libroTrabajoSalida = Workbook.createWorkbook(ArchivoExcelSalida, libroTrabajo);
//cerramos el libro para poder trabajar sobre el
this.abiertoCerradoLibroEntrada = false;
libroTrabajo.close();
} catch (IOException ex) {
Logger.getLogger(ArchivoExcelBaseConocimiento.class.getName()).log(Level.SEVERE, null, ex);
}
WritableSheet sheetCoordenadas = libroTrabajoSalida.getSheet(this.hojaHeuristica);
//Primero completamos la nueva columna
for (int i = 0; i < limiteHeuristica.getFilas() + 1; i++) {
Number heuristicaCol = new Number(limiteHeuristica.getColumnas() + 1, i + 1, 0);
try {
sheetCoordenadas.addCell(heuristicaCol);
} catch (WriteException ex) {
System.out.println("Aqui es el error");
Logger.getLogger(ArchivoExcelBaseConocimiento.class.getName()).log(Level.SEVERE, null, ex);
}
}
//Segundo completamos la nueva fila
for (int i = 0; i < limiteHeuristica.getColumnas() + 1; i++) {
Number heuristicaFila = new Number(i + 1, limiteHeuristica.getFilas() + 1, 0);
try {
sheetCoordenadas.addCell(heuristicaFila);
} catch (WriteException ex) {
System.out.println("Aqui es el error");
Logger.getLogger(ArchivoExcelBaseConocimiento.class.getName()).log(Level.SEVERE, null, ex);
}
}
try {
libroTrabajoSalida.write();
libroTrabajoSalida.close();
} catch (IOException ex) {
Logger.getLogger(ArchivoExcelBaseConocimiento.class.getName()).log(Level.SEVERE, null, ex);
} catch (WriteException ex) {
Logger.getLogger(ArchivoExcelBaseConocimiento.class.getName()).log(Level.SEVERE, null, ex);
}
//En este momento guardamos los valores en la parte de configuracion
boolean guardarConfiguracionE = guardarConfiguracion(ArchivoExcelBaseConocimiento.HEURISTICA, limiteHeuristica.getFilas() + 1, limiteHeuristica.getColumnas() + 1);
if (guardarConfiguracionE) {
System.out.println("Se guardo correctamente la nueva heuristica");
} else {
System.out.println("Problemas al guardar la nueva heuristica");
}
return true;
}
/**
*
* @param coordenadaX nueva coordenada X generada para un barrio o punto
* @param coordenadaY nueva coordenada Y generada para un barrio o punto
* @return boolean estado el cual nos indica si se a guardado correctamente o no un dato
*/
public boolean guardarCoordenada(int coordenadaX, int coordenadaY) {
Limite limiteCoordenadas = leerLimites(ArchivoExcelBaseConocimiento.COORDENADASPUNTOS);
try {
if (!this.abiertoCerradoLibroEntrada) {
//esta cerrado entonces abrimos el archivo
System.out.println("Punto 1");
System.out.println("ARCHIVO ENTRADA: CERRADO-ABIERTO");
abrirArchivoEntrada();
} else {
System.out.println("Punto 2");
System.out.println("ARCHIVO ENTRADA: ABIERTO-CERRADO");
}
libroTrabajoSalida = Workbook.createWorkbook(ArchivoExcelSalida, libroTrabajo);
//cerramos el libro para poder trabajar sobre el
this.abiertoCerradoLibroEntrada = false;
libroTrabajo.close();
} catch (IOException ex) {
Logger.getLogger(ArchivoExcelBaseConocimiento.class.getName()).log(Level.SEVERE, null, ex);
}
WritableSheet sheetCoordenadas = libroTrabajoSalida.getSheet(this.hojaCoordenadasPuntos);
Number coordenadaXCelda = new Number(1, limiteCoordenadas.getFilas() + 1, coordenadaX);
Number coordenadaYCelda = new Number(2, limiteCoordenadas.getFilas() + 1, coordenadaY);
try {
sheetCoordenadas.addCell(coordenadaXCelda);
sheetCoordenadas.addCell(coordenadaYCelda);
} catch (WriteException ex) {
System.out.println("Aqui es el error");
Logger.getLogger(ArchivoExcelBaseConocimiento.class.getName()).log(Level.SEVERE, null, ex);
}
try {
libroTrabajoSalida.write();
libroTrabajoSalida.close();
} catch (IOException ex) {
Logger.getLogger(ArchivoExcelBaseConocimiento.class.getName()).log(Level.SEVERE, null, ex);
} catch (WriteException ex) {
Logger.getLogger(ArchivoExcelBaseConocimiento.class.getName()).log(Level.SEVERE, null, ex);
}
//En este momento guardamos los valores en la parte de configuracion
boolean guardarConfiguracionE = guardarConfiguracion(ArchivoExcelBaseConocimiento.COORDENADASPUNTOS, limiteCoordenadas.getFilas() + 1, limiteCoordenadas.getColumnas());
if (guardarConfiguracionE) {
System.out.println("Se guardo correctamente la nueva regla");
} else {
System.out.println("Problemas al guardar la nueva regla ");
}
return true;
}
/**
*
* @param tipo Para especificar el tipo de elemento a modificar
* <h4>Posibilidades:</h4>
* <ui>
* <li>NOMBRESPUNTOS</li>
* <li>COORDENADASPUNTOS</li>
* <li>HEURISTICA</li>
* <li>REGLAS</li>
* </ui>
* @param numeroFilas Numero de Filas de un elemento a configurar
* @param numeroColumnas Numero de Columnas de un elemento a configurar
* @return estado para saber si guarda correctamente las configuraciones
*/
public boolean guardarConfiguracion(int tipo, int numeroFilas, int numeroColumnas) {
try {
if (!this.abiertoCerradoLibroEntrada) {
//esta cerrado entonces abrimos el archivo
System.out.println("ARCHIVO ENTRADA: CERRADO-ABIERTO");
abrirArchivoEntrada();
} else {
System.out.println("ARCHIVO ENTRADA: ABIERTO-CERRADO");
}
libroTrabajoSalida = Workbook.createWorkbook(ArchivoExcelSalida, libroTrabajo);
//cerramos el libro para poder trabajar sobre el
this.abiertoCerradoLibroEntrada = false;
libroTrabajo.close();
} catch (IOException ex) {
Logger.getLogger(ArchivoExcelBaseConocimiento.class.getName()).log(Level.SEVERE, null, ex);
}
if (tipo == ArchivoExcelBaseConocimiento.REGLAS) {
WritableSheet sheetReglas = libroTrabajoSalida.getSheet(this.hojaConfiguraciones);
//recordar que primero son las columnas y luego filas
WritableCell celdaFilas = sheetReglas.getWritableCell(1, 3);
WritableCell celdaColumnas = sheetReglas.getWritableCell(2, 3);
if (celdaFilas.getType() == CellType.NUMBER) {
Number n = (Number) celdaFilas;
n.setValue(numeroFilas);
}
if (celdaColumnas.getType() == CellType.NUMBER) {
Number n = (Number) celdaColumnas;
n.setValue(numeroColumnas);
}
} else if (tipo == ArchivoExcelBaseConocimiento.NOMBRESPUNTOS) {
WritableSheet sheetReglas = libroTrabajoSalida.getSheet(this.hojaConfiguraciones);
//recordar que primero son las columnas y luego filas
WritableCell celdaFilas = sheetReglas.getWritableCell(1, 2);
WritableCell celdaColumnas = sheetReglas.getWritableCell(2, 2);
if (celdaFilas.getType() == CellType.NUMBER) {
Number n = (Number) celdaFilas;
n.setValue(numeroFilas);
}
if (celdaColumnas.getType() == CellType.NUMBER) {
Number n = (Number) celdaColumnas;
n.setValue(numeroColumnas);
}
} else if (tipo == ArchivoExcelBaseConocimiento.HEURISTICA) {
WritableSheet sheetReglas = libroTrabajoSalida.getSheet(this.hojaConfiguraciones);
//recordar que primero son las columnas y luego filas
WritableCell celdaFilas = sheetReglas.getWritableCell(1, 1);
WritableCell celdaColumnas = sheetReglas.getWritableCell(2, 1);
if (celdaFilas.getType() == CellType.NUMBER) {
Number n = (Number) celdaFilas;
n.setValue(numeroFilas);
}
if (celdaColumnas.getType() == CellType.NUMBER) {
Number n = (Number) celdaColumnas;
n.setValue(numeroColumnas);
}
} else if (tipo == ArchivoExcelBaseConocimiento.COORDENADASPUNTOS) {
WritableSheet sheetReglas = libroTrabajoSalida.getSheet(this.hojaConfiguraciones);
//recordar que primero son las columnas y luego filas
WritableCell celdaFilas = sheetReglas.getWritableCell(1, 0);
WritableCell celdaColumnas = sheetReglas.getWritableCell(2, 0);
if (celdaFilas.getType() == CellType.NUMBER) {
Number n = (Number) celdaFilas;
n.setValue(numeroFilas);
}
if (celdaColumnas.getType() == CellType.NUMBER) {
Number n = (Number) celdaColumnas;
n.setValue(numeroColumnas);
}
}
try {
libroTrabajoSalida.write();
libroTrabajoSalida.close();
} catch (IOException ex) {
Logger.getLogger(ArchivoExcelBaseConocimiento.class.getName()).log(Level.SEVERE, null, ex);
} catch (WriteException ex) {
Logger.getLogger(ArchivoExcelBaseConocimiento.class.getName()).log(Level.SEVERE, null, ex);
}
return true;
}
/**
*
* @param elemento Una constante que define el elemento del cual queremos sacar los limites
* <h4>Posibilidades:</h4>
* <ui>
* <li>NOMBRESPUNTOS</li>
* <li>COORDENADASPUNTOS</li>
* <li>HEURISTICA</li>
* <li>REGLAS</li>
* </ui>
* @return int [] Un arreglo que contiene los limites de los distintos elementos de la base del conocimiento.
* <hr>
* <h4>Ejemplo:</h4>
* {@code leerLimites(ArchivoExcelBaseConocimiento.HEURISTICA);}
*/
public Limite leerLimites(int elemento) {
if (!this.abiertoCerradoLibroEntrada) {
//esta cerrado entonces abrimos el archivo
System.out.println("ARCHIVO ENTRADA: CERRADO-ABIERTO");
abrirArchivoEntrada();
} else {
System.out.println("ARCHIVO ENTRADA: ABIERTO-CERRADO");
}
int columnas, filas;
if (elemento == ArchivoExcelBaseConocimiento.REGLAS) {
System.out.println("Limite reglas");
Sheet sheet = libroTrabajo.getSheet(this.hojaConfiguraciones);
//recordar que primero son las columnas y luego filas
Cell a1 = sheet.getCell(1, 3);
Cell b2 = sheet.getCell(2, 3);
String stringfilas = a1.getContents();
String strincolumnas = b2.getContents();
columnas = Integer.parseInt(strincolumnas);
filas = Integer.parseInt(stringfilas);
System.out.println("filas: " + stringfilas + "\ncolumnas: " + strincolumnas);
return new Limite(filas, columnas);
} else if (elemento == ArchivoExcelBaseConocimiento.NOMBRESPUNTOS) {
System.out.println("Limite nombre puntos");
Sheet sheet = libroTrabajo.getSheet(this.hojaConfiguraciones);
//recordar que primero son las columnas y luego filas
Cell a1 = sheet.getCell(1, 2);
Cell b2 = sheet.getCell(2, 2);
String stringfilas = a1.getContents();
String strincolumnas = b2.getContents();
columnas = Integer.parseInt(strincolumnas);
filas = Integer.parseInt(stringfilas);
System.out.println("filas: " + stringfilas + "\ncolumnas: " + strincolumnas);
return new Limite(filas, columnas);
} else if (elemento == ArchivoExcelBaseConocimiento.HEURISTICA) {
System.out.println("Limite heuristica");
Sheet sheet = libroTrabajo.getSheet(this.hojaConfiguraciones);
//recordar que primero son las columnas y luego filas
Cell a1 = sheet.getCell(1, 1);
Cell b2 = sheet.getCell(2, 1);
String stringfilas = a1.getContents();
String strincolumnas = b2.getContents();
columnas = Integer.parseInt(strincolumnas);
filas = Integer.parseInt(stringfilas);
System.out.println("filas: " + stringfilas + "\ncolumnas: " + strincolumnas);
return new Limite(filas, columnas);
} else if (elemento == ArchivoExcelBaseConocimiento.COORDENADASPUNTOS) {
System.out.println("Limite coordenada puntos");
Sheet sheet = libroTrabajo.getSheet(this.hojaConfiguraciones);
//recordar que primero son las columnas y luego filas
Cell a1 = sheet.getCell(1, 0);
Cell b2 = sheet.getCell(2, 0);
String stringfilas = a1.getContents();
String strincolumnas = b2.getContents();
columnas = Integer.parseInt(strincolumnas);
filas = Integer.parseInt(stringfilas);
System.out.println("filas: " + stringfilas + "\ncolumnas: " + strincolumnas);
return new Limite(filas, columnas);
}
return null;
}
/**
*
* @param nombreArchivo Archivo Excel que contiene la base de conocimiento
* @param hojaNombresPuntos Nombre de la hoja del archivo de excel que contiene nombre de los puntos
* @param hojaCoordenadasPuntos Nombre de la hoja del archivo de excel que contiene las coordenadas de los puntos
* @param hojaHeuristica Nombre de la hoja del archivo de excel que contiene las heurusticas del problema
* @param hojaReglas Nombre de la hoja del archivo de excel que contiene las reglas
* @param hojaConfiguraciones Nombre de la hoja del archivo de excel que contiene las configuraciones de los distintos elementos de la Base de conocimiento
*/
public ArchivoExcelBaseConocimiento(String nombreArchivo, String hojaNombresPuntos, String hojaCoordenadasPuntos, String hojaHeuristica, String hojaReglas, String hojaConfiguraciones) {
this.nombreArchivo = nombreArchivo;
this.hojaNombresPuntos = hojaNombresPuntos;
this.hojaCoordenadasPuntos = hojaCoordenadasPuntos;
this.hojaHeuristica = hojaHeuristica;
this.hojaReglas = hojaReglas;
this.hojaConfiguraciones = hojaConfiguraciones;
this.ArchivoExcelEntrada = new File(nombreArchivo);
this.ArchivoExcelSalida = new File(nombreArchivo);
try {
this.libroTrabajo = Workbook.getWorkbook(ArchivoExcelEntrada);
this.abiertoCerradoLibroEntrada = true;
} catch (IOException ex) {
Logger.getLogger(ArchivoExcelBaseConocimiento.class.getName()).log(Level.SEVERE, null, ex);
} catch (BiffException ex) {
Logger.getLogger(ArchivoExcelBaseConocimiento.class.getName()).log(Level.SEVERE, null, ex);
}
}
/**
*
* @return Estado de apertura del archivo de entrada
* <h4>Posibilidades:</h4>
* <ui>
* <li>true El archivo a sido abierto correctamente </li>
* <li>false El archivo a sido abierto erronamente</li>
* </ui>
*/
public boolean abrirArchivoEntrada() {
try {
if (this.abiertoCerradoLibroSalida) {
System.out.println("SALIDA: ABIERTO-CERRADO");
this.libroTrabajoSalida.close();
} else {
System.out.println("SALIDA: CERRADO");
}
this.libroTrabajo = Workbook.getWorkbook(ArchivoExcelEntrada);
this.abiertoCerradoLibroSalida = false;
this.abiertoCerradoLibroEntrada = true;
return true;
} catch (IOException ex) {
Logger.getLogger(ArchivoExcelBaseConocimiento.class.getName()).log(Level.SEVERE, null, ex);
return false;
} catch (BiffException ex) {
Logger.getLogger(ArchivoExcelBaseConocimiento.class.getName()).log(Level.SEVERE, null, ex);
return false;
} catch (WriteException ex) {
Logger.getLogger(ArchivoExcelBaseConocimiento.class.getName()).log(Level.SEVERE, null, ex);
return false;
}
}
/**
*
* @return Estado de apertura del archivo de salida
* <h4>Posibilidades:</h4>
* <ui>
* <li>true El archivo a sido abierto correctamente </li>
* <li>false El archivo a sido abierto erronamente</li>
* </ui>
*/
public boolean abrirArchivoSalida() {
try {
this.libroTrabajoSalida = Workbook.createWorkbook(ArchivoExcelSalida, libroTrabajo);
this.libroTrabajo.close();
//cerramos el libro para poder trabajar sobre el
this.abiertoCerradoLibroEntrada = false;
return true;
} catch (IOException ex) {
Logger.getLogger(ArchivoExcelBaseConocimiento.class.getName()).log(Level.SEVERE, null, ex);
return false;
}
}
/***
* Constructor por default, el cual contiene un archivo por default de la base de conocimiento
**/
public ArchivoExcelBaseConocimiento() {
this.nombreArchivo = ResourceBundle.getBundle("baseconocimiento.resources.Configuracion").getString("Base_conocimiento");
this.hojaNombresPuntos = "IndicesNombres";
this.hojaCoordenadasPuntos = "CoordenadasBarrios";
this.hojaHeuristica = "Heuristica";
this.hojaReglas = "Reglas";
this.hojaConfiguraciones = "Configuraciones";
this.ArchivoExcelEntrada = new File(nombreArchivo);
this.ArchivoExcelSalida = new File(nombreArchivo);
try {
this.libroTrabajo = Workbook.getWorkbook(ArchivoExcelEntrada);
this.abiertoCerradoLibroEntrada = true;
} catch (IOException ex) {
Logger.getLogger(ArchivoExcelBaseConocimiento.class.getName()).log(Level.SEVERE, null, ex);
System.exit(0);
} catch (BiffException ex) {
Logger.getLogger(ArchivoExcelBaseConocimiento.class.getName()).log(Level.SEVERE, null, ex);
System.exit(0);
}catch (Exception e){
System.exit(0);
}
}
/**
*
* @param args
*/
public static void main(String[] args) {
ArchivoExcelBaseConocimiento base = new ArchivoExcelBaseConocimiento();
/*base.guardarConfiguracion(ArchivoExcelBaseConocimiento.COORDENADASPUNTOS, 9, 2);
base.guardarConfiguracion(ArchivoExcelBaseConocimiento.HEURISTICA, 9, 9);
base.guardarConfiguracion(ArchivoExcelBaseConocimiento.NOMBRESPUNTOS, 9, 2);
base.guardarConfiguracion(ArchivoExcelBaseConocimiento.REGLAS, 9, 5); */
ArrayList<Barrio> barrios= base.leerBarrios();
for (Barrio barrio : barrios) {
System.out.println(barrio);
}
base.leerReglas();
//base.leerLimites(COORDENADASPUNTOS);
//base.leerReglas();
//base.guardarCoordenada(30, 30);
//base.leerCoordenadasPuntos();
//base.guardarCoordenada(30, 40);
//base.guardarHeuristica(20, 20);
//Limite limiteCoordenadas= base.leerLimites(ArchivoExcelBaseConocimiento.COORDENADASPUNTOS);
//base.guardarConfiguracion(ArchivoExcelBaseConocimiento.REGLAS, 9, 5);
}
}