| gvSIG desktop 1

package es.logex.callejero.modelo;

import java.util.*;

import org.postgis.PGgeometry;

public class Feature {

	private List<DataElement> data;

	private GeometryElement geometry;

	private String name;

	public Feature(String name) {

		this.name = name;

	}

	public List<DataElement> getData() {

		return data;

	}

	public void setData(List<DataElement> data) {

		this.data = data;

	}

	public GeometryElement getGeometryElement() {

		return geometry;

	}

	public void setGeometry(GeometryElement geometry) {

		this.geometry = geometry;

	}

	public PGgeometry getGeometryObject() {

		return geometry.getGeometry();

	}

	public void setGeometry(Object geometry) {

		this.geometry.setGeometry(geometry);

	}

	public String getName() {

		return name;

	}

	public void setName(String name) {

		this.name = name;

	}

}

package es.logex.callejero.modelo;

public class BoundingBox {

	private double[] lowersBoundingBox;

	private double[] uppersBoundingBox;

	private String crsBoundingBox; //en formato epsg.xml#XXXXX donde XXXXX=SRID

	public BoundingBox() {

	}

	public BoundingBox(double[] lowersBoundingBox,double[] uppersBoundingBox,String crsBoundingBox){

		this.crsBoundingBox = crsBoundingBox;

		this.lowersBoundingBox = lowersBoundingBox;

		this.uppersBoundingBox = uppersBoundingBox; 

	}

	public BoundingBox(Double[] lowersBoundingBox,Double[] uppersBoundingBox,String crsBoundingBox){

		this.crsBoundingBox = crsBoundingBox;

		this.lowersBoundingBox = new double[2];

		for (int i = 0; i < lowersBoundingBox.length; i++){

			this.lowersBoundingBox[i] = (double)lowersBoundingBox[i];

		}

		this.uppersBoundingBox = new double[2];

		for (int j = 0; j < uppersBoundingBox.length; j++){

			this.uppersBoundingBox[j] = (double)uppersBoundingBox[j];

		}

	}

	public String getCrsBoundingBox() {

		return crsBoundingBox;

	}

	public void setCrsBoundingBox(String crsBoundingBox) {

		this.crsBoundingBox = crsBoundingBox;

	}

	public double[] getLowersBoundingBox() {

		return lowersBoundingBox;

	}

	public void setLowersBoundingBox(double[] lowersBoundingBox) {

		this.lowersBoundingBox = lowersBoundingBox;

	}

	public double[] getUppersBoundingBox() {

		return uppersBoundingBox;

	}

	public void setUppersBoundingBox(double[] uppersBoundingBox) {

		this.uppersBoundingBox = uppersBoundingBox;

	}

	public String toString(){

		return "(" + this.lowersBoundingBox[0] + " " + this.lowersBoundingBox[1] + "," + 

					this.uppersBoundingBox[0] + " " + this.uppersBoundingBox[1] + ")";

	}

	/***

	 * Devuelve el SRID del bounding box.

	 * @throws Exception 

	 *

	 */

	public String getSRID() throws Exception {

		int index = this.crsBoundingBox.lastIndexOf("#"); //para formatos epsg.xml#

		if (index > 0 && index <  this.crsBoundingBox.length() -1) { 

			return this.crsBoundingBox.substring(index +1 , this.crsBoundingBox.length());

		} else {

			index = this.crsBoundingBox.lastIndexOf(":");

			if (index > 0 && index <  this.crsBoundingBox.length() -1) 

				return this.crsBoundingBox.substring(index +1 , this.crsBoundingBox.length());

		}

		throw new Exception("El formato del sistema de referencia no es OGC compliant(ejemplo: epsg.xml#23030)");

	}

}

package es.logex.callejero.modelo;

public class DataElement {

	private String name;

	private String value;

	public DataElement(String name, String value){

		setName(name);

		setValue(value);

	}

	public String getName() {

		return name;

	}

	public void setName(String name) {

		this.name = name;

	}

	public String getValue() {

		return value;

	}

	public void setValue(String value) {

		this.value = value;

	}

}

package es.logex.callejero.modelo;

import org.postgis.PGgeometry;

public class GeometryElement {

	private String name;

	public String getName() {

		return name;

	}

	public void setName(String name) {

		this.name = name;

	}

	private PGgeometry geometry; 

	public PGgeometry getGeometry() {

		return geometry;

	}

	public void setGeometry(PGgeometry geometry) {

		this.geometry = geometry;

	}

	public void setGeometry(Object geometry) {

		this.geometry = (PGgeometry) geometry;

	}

}

package es.logex.callejero.exceptions;

public class LayerBoundingBoxNulo extends Exception {

	/**

	 * 

	 */

	private static final long serialVersionUID = -5106823702548439322L;

	public LayerBoundingBoxNulo() {

	        super();

	        // TODO Auto-generated constructor stub

	    }

	    /**

	     * DOCUMENT ME!

	     *

	     * @param message

	     */

	    public LayerBoundingBoxNulo(String message) {

	        super(message);

	        // TODO Auto-generated constructor stub

	    }

	    /**

	     * DOCUMENT ME!

	     *

	     * @param message

	     * @param cause

	     */

	    public LayerBoundingBoxNulo(String message, Throwable cause) {

	        super(message, cause);

	        // TODO Auto-generated constructor stub

	    }

	    /**

	     * DOCUMENT ME!

	     *

	     * @param cause

	     */

	    public LayerBoundingBoxNulo(Throwable cause) {

	        super(cause);

	        // TODO Auto-generated constructor stub

	    } 

}

package es.logex.callejero.exceptions;

public class LayerConnectionNula extends Exception{

	/**

	 * 

	 */

	private static final long serialVersionUID = 3961618904459405883L;

	public LayerConnectionNula() {

        super();

        // TODO Auto-generated constructor stub

    }

    /**

     * DOCUMENT ME!

     *

     * @param message

     */

    public LayerConnectionNula(String message) {

        super(message);

        // TODO Auto-generated constructor stub

    }

    /**

     * DOCUMENT ME!

     *

     * @param message

     * @param cause

     */

    public LayerConnectionNula(String message, Throwable cause) {

        super(message, cause);

        // TODO Auto-generated constructor stub

    }

    /**

     * DOCUMENT ME!

     *

     * @param cause

     */

    public LayerConnectionNula(Throwable cause) {

        super(cause);

        // TODO Auto-generated constructor stub

    } 

}

package es.logex.callejero.exceptions;

import org.gvsig.gpe.GPEErrorHandler;

public class CallejeroGPEErrorHandler extends GPEErrorHandler {

}

/**

 * 

 */

package es.logex.callejero.core;

import java.awt.geom.Rectangle2D;

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

import java.util.ArrayList;

import java.util.List;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.postgis.PGbox2d;

import es.logex.callejero.modelo.BoundingBox;

/* logEx. Lógica Extrema s.l.*

* Copyright (C) 2007 Lógica Extrema and Generalitat Valenciana.

*

* This program is free software; you can redistribute it and/or

* modify it under the terms of the GNU General Public License

* as published by the Free Software Foundation; either version 2

* of the License, or (at your option) any later version.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

* GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

*

* For more information, contact:

*

*  Generalitat Valenciana

*   Conselleria d'Infraestructures i Transport

*   Av. Blasco Ibañez, 50

*   46010 VALENCIA

*   SPAIN

*

*      +34 963862235

*   gvsig@gva.es

*      www.gvsig.gva.es

*

*    or

*

*   Lógica Extrema s.l.

*   Avda. Cortes Valencianas

*   46015 Valencia

*   Spain

*

*   logic@logex.es

*/

/**

 * @author kike

 *

 */

public   class Callejero implements ICallejero {

	Log log = LogFactory.getLog(this.getClass());

	private static List<String> municipios = new ArrayList<String>();

	public Connection conn = null;

	public Callejero(Connection conn) {

		this.conn = conn;

	}

	private ResultSet EjecutaSql(String query) {

		ResultSet r= null;

		try {

			if(log.isDebugEnabled())

			{

				log.debug("Executing SQL:" + query);

			}

				Statement s = conn.createStatement();

				r = s.executeQuery(query);

		}catch (Exception e){

			log.error(e.getMessage());

		}

			return r;

	}

	/***

	 * Devuelve una lista de candidatos a partir de un municipio, calle, número

	 * 

	 */

	public List<String> getCandidatos(String municipio, String calle, String numero) {

		String candMunicipio = null;

		if (municipio == null) 

			candMunicipio = "";

		else

			candMunicipio = municipio;

		String candCalle = null;

		if (calle == null)

			candCalle  = "";

		else

			candCalle = calle;

		String candNumero = null;

		if (numero == null) 

			candNumero  = "";

		else

			candNumero = numero;

		String query = null;

		ResultSet r = null;

		List<String> lista = new ArrayList<String>();

		log.debug("Decidir query en función de parámetros ");

		if ( !candMunicipio.equals("")) { //hay municipio

			if (candCalle.equals("")) { //municipio sin calle

				/*query = "select municipio  as texto_candidato,LogexLevenshtein('" + candMunicipio.toUpperCase() + 

				"',municipio) , extent from candidatos_extent where calle isnull order by LogexLevenshtein('" +

				candMunicipio.toUpperCase() + "',municipio) ASC LIMIT 10";*/

				query = "select municipio  as texto_candidato,Levenshtein('" + candMunicipio.toUpperCase() + 

				"',municipio) , extent from candidatos_extent where calle isnull order by Levenshtein('" +

				candMunicipio.toUpperCase() + "',municipio) ASC LIMIT 10";

			} else { //municipio con calle

				query = "select municipio || ' - ' ||calle  as texto_candidato,LogexLevenshtein('" + candCalle.toUpperCase() + 

				"',calle), Levenshtein('" + candMunicipio.toUpperCase() +"',municipio), extent " + 

				" from candidatos_extent order by LogexLevenshtein('" +	candCalle.toUpperCase() + "',calle)  + " + 

				" Levenshtein('" +	candMunicipio.toUpperCase() + "',municipio) ASC LIMIT 10";

			}

		}	else { //solo calle

			if (!candCalle.equals("")) {

				query = "select municipio || ' - ' ||calle as texto_candidato,LogexLevenshtein('" + candCalle.toUpperCase() + 

				"',calle) , extent from candidatos_extent order by LogexLevenshtein('" +

				candCalle.toUpperCase() + "',calle) ASC LIMIT 10";

			}

		}

		if (query == null)

			return lista;

		log.debug("Ejecutar query "  + query);

		r = this.EjecutaSql(query);

		String text;

		BoundingBox extent = new BoundingBox();

		try {

			while (r.next()) {

				PGbox2d pgBox = new PGbox2d(r.getString("extent"));

				double[] lowers = {pgBox.getLLB().x, pgBox.getLLB().y};

				double[] uppers = {pgBox.getURT().x, pgBox.getURT().y};

				extent.setLowersBoundingBox(lowers);

				extent.setUppersBoundingBox(uppers);

				lista.add(r.getString("texto_candidato") + "#$" + extent.toString());

			}

		} catch (SQLException e) {

			log.error(e.getMessage(),e);

		} finally{

			if(r!=null)

			{

				try {

					r.close();

				} catch (SQLException e) {

					log.error(e.getMessage(),e);

				}

			}

		}

		return lista;

	}

	/**

	 * Devuelve una lista con los nombres de todos los municipios de la base de datos

	 * 

	 * @return una lista de municipios

	 */

  	public List<String> getMunicipios() {

  		ResultSet r = null;

  		try{

 	  		if (this.municipios.isEmpty() ) {

 	  			log.debug("Municipios vacío. Se llena por primera vez");

 	  			r = this.EjecutaSql("select * from municipios");

 	  			while (r.next()) {

	  			      	municipios.add(r.getString("ine_denomina"));

	  			    }

	  	  		log.debug("Añadidos " + r.getRow() + "municipios a Callejero.municipios");

 	  		}

		}catch (Exception e) {

			log.error(e.getMessage(),e);

		}

		finally{

			if(r!=null)

			{

				try {

					r.close();

				} catch (SQLException e) {

					// TODO Auto-generated catch block

					e.printStackTrace();

				}

			}

		}

		return municipios;

  	}

  	/**

  	 * Dado el nombre de un municipio devuelve los 10 mejores

  	 * candidatos. Si se encuentra un municipio con el mismo nombre

  	 * sólo se devuelve el municipio encontrado.

  	 */

  	public List<String> getMunicipiosLV(String municipio){

  		ResultSet r = null;

	  	List<String> retMunis = new ArrayList<String>();

  		try{

 	  			r = this.EjecutaSql("select distinct ine_denomina, levenshtein(upper('"+municipio+

 	  					"'),upper(BUSQUEDA)) from municipios order by levenshtein(upper('"+municipio+

 	  					"'),upper(BUSQUEDA)) asc LIMIT 10");

 	  			while (r.next()) {

 	  					retMunis.add(r.getString("ine_denomina"));

	  			 } 	  			

		}catch (Exception e) {

			log.error(e.getMessage(),e);

		}

		finally{

			if(r!=null)

			{

				try {

					r.close();

				} catch (SQLException e) {

					// TODO Auto-generated catch block

					e.printStackTrace();

				}

			}

		}

		return retMunis;

//  		LevenshteinDistance lv = new LevenshteinDistance();;

//  		List<String> lista = new ArrayList<String>();

//  		

//  		 return lv.getTopX(municipio, getMunicipios(),10);

  	}

  	/**

  	 * Devuelve el mapa con sus layers, cada layer tendrá su gmldocument

  	 */

  	public IMap getMapFromExtent(BoundingBox box) {

  		IMap map = null;

  		return map;

  	}

  	/**

  	 * Devuelve el extent máximo de la capa especificada. Quizás debería estar en un package de utils...

  	 * y devolver los máximos...

  	 * @return

  	 * @throws Exception

  	 */

  	public Rectangle2D getMaxExtent(String layerName) throws Exception{

  		ResultSet r = null;

		Statement s = null;

		PGbox2d pgBox = null;

		try {

			s = conn.createStatement();

			r = s.executeQuery("SELECT EXTENT(the_GEOM) as bbox FROM " + layerName);

		   if (r.next() ) {

			 pgBox = (PGbox2d) r.getObject("bbox");

		   }

		   Rectangle2D rec = new Rectangle2D.Double(pgBox.getLLB().x,pgBox.getLLB().y,

				   			pgBox.getURT().x-pgBox.getLLB().x, pgBox.getURT().y-pgBox.getLLB().y) ;

		   return rec;

		} catch (SQLException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

			throw e;

		}

  	}

  	public ArrayList<String> getLayerList() {

  	   ArrayList<String> list = new ArrayList<String>();

  	   return list;

   	}

 }

/**

 * 

 */

package es.logex.callejero.core;

import java.io.File;

import java.io.OutputStream;

import java.util.List;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.gvsig.gpe.GPEErrorHandler;

import org.gvsig.gpe.GPERegister;

import org.gvsig.gpe.writers.GPEWriterHandler;

import org.postgis.Geometry;

import org.postgis.LineString;

import org.postgis.MultiLineString;

import org.postgis.MultiPolygon;

import org.postgis.PGgeometry;

import org.postgis.Point;

import org.postgis.Polygon;

import es.logex.callejero.exceptions.CallejeroGPEErrorHandler;

import es.logex.callejero.modelo.BoundingBox;

import es.logex.callejero.modelo.DataElement;

import es.logex.callejero.modelo.GeometryElement;

import es.logex.utils.ConvertUtils;

/**

 * @author kike

 *

 */

public class GMLProducer  {

	/*private String filename = "FILETEMP";

	private GPEWriterHandler writerHandler = null;

	private GPEContentHandler contenHandler = null;

	private GPEErrorHandler errorHandler = null;

	private GPEParser parser = null;

	private File outputFile = null;*/

	private String outputFileName = "";

	private GPEWriterHandler writer = null;

	private String writerName = "GML writer";

	private GPEErrorHandler errorHandler;

	private String outPath = null;

	ILayer layer = null;

	Long i = 0L;

	Log log = LogFactory.getLog(this.getClass()); 

	public GMLProducer(ILayer _layer,String outPath){

		log.debug("Constructor donde se rellenan los valores del writer");

		this.outPath = outPath;

		this.layer = _layer;

		//GPEDefaults.setProperty(GPEDefaults.DEFAULT_FILE_NAME, outputFileName);

		//GPEDefaults.setProperty(GPEDefaults.XSD_SCHEMA_FILE, schema);

		//GPEDefaults.setProperty(GPEDefaults.COORDINATES_SEPARATOR, GPEDefaults.DEFAULT_BLANC_SPACE);

		//GPEDefaults.setProperty(GPEDefaults.DECIMAL, )

		try{

			//Register the writer

			GPERegister.addGpeWriterHandler(writerName,"Writer de GML hasta la versión 2.1",

					org.gvsig.gpe.gml.writer.GPEGmlv2WriterHandlerImplementor.class);

			//Gets the writer

			writer = GPERegister.createWriter(writerName);	

			errorHandler = new CallejeroGPEErrorHandler();

			writer.setErrorHandler(errorHandler);

			this.outputFileName = this.outPath + File.separatorChar + System.currentTimeMillis() + "_"+ layer.getName() + ".gml";

			writer.setFileName(outputFileName);

			log.debug("Ok. El writer está creado");

		} catch (Exception e){

			log.error("Error inicializando el writer");

			log.error(e.getMessage());

		}

	}

    public void writeHeadGmlFile() throws Throwable {

    	try {

		    	//this.crs = layer.getExtent().getCrsBoundingBox();

		    	//    	si no tenemos esquema, que ponga el nombre de la capa.xsd

				/*if (schema=="") {

					GPEDefaults.setProperty(GPEDefaults.XSD_SCHEMA_FILE, layer.getName() + ".xsd");

				}*/

				/*if (outputFileName == "") {

					GPEDefaults.setProperty(GPEDefaults.DEFAULT_FILE_NAME, layer.getName());

				}*/

				writer.initialize();

				writer.startLayer("1", layer.getName(), layer.getDescription(),null ,null);

				BoundingBox box = layer.getExtent();

				double xb[] = {box.getLowersBoundingBox()[0],box.getUppersBoundingBox()[0]} ;

				double yb[] = {box.getLowersBoundingBox()[1],box.getUppersBoundingBox()[1]} ;

				double[] emptyZ = new double[2];

				writer.startBbox("box" ,xb, yb, emptyZ, box.getCrsBoundingBox());

				writer.endBbox();

    	} finally {

    		if (errorHandler.getErrorsSize() > 0) {

    			throw new Throwable(errorHandler.getErrorAt(0));

    		}

    	}

    }

    public void writeStartFeature() throws Throwable{

      	try {

    		i+=1;

        	writer.startFeature("f" + i,layer.getName(),null);

    	} finally {

    		if (errorHandler.getErrorsSize() > 0) {

    			throw new Throwable(errorHandler.getErrorAt(0));

    		}

    	}

    }

    public  void writeGeomElement(GeometryElement geomElement) throws Throwable{

		try {

				PGgeometry geom = geomElement.getGeometry();

				if (geomElement != null) {

					writer.startElement(geomElement.getName(), null , null);

					switch (geom.getGeoType()) {

						case Geometry.MULTIPOLYGON:

							MultiPolygon multip = (MultiPolygon) geom.getGeometry(); 

							writer.startMultiPolygon(Long.toString(i),null);

							for (Polygon p : multip.getPolygons() ) {

								///TODO: No seguir si tiene más de un anillo.

								//extraer en arrays las coordenadas

								double[] x = new double[p.numPoints()];

								double[] y = new double[p.numPoints()];

								double[] z = new double[p.numPoints()];

								ConvertUtils.ConvertCoordinatesToXYZ(p, x, y, z);

								writer.startPolygon("p" + i, x, y, z,null);

								writer.endPolygon();

							}

							writer.endMultiPolygon();

							writer.endElement();

							break;

						case Geometry.MULTILINESTRING:

							MultiLineString multil = (MultiLineString) geom.getGeometry();

							writer.startMultiLineString(Long.toString(i),null);

							for (LineString ls : multil.getLines()) {

								double[] x = new double[ls.numPoints()];

								double[] y = new double[ls.numPoints()];

								double[] z = new double[ls.numPoints()];

								ConvertUtils.ConvertCoordinatesToXYZ(ls, x, y, z);

								writer.startLineString("l" + i, x, y, z, null);

							    writer.endLineString();

							}

							writer.endMultiLineString();

							writer.endElement();

							break;

						case Geometry.POINT:

							Point p = (Point) geom.getGeometry();

							writer.startPoint("l" + i, p.x, p.y, p.z, null);

						    writer.endPoint();

							writer.endElement();

							//writer.endFeature();

							break;

						default:

							break;

					}

				}

		} finally {

    		if (errorHandler.getErrorsSize() > 0) {

    			throw new Throwable(errorHandler.getErrorAt(0));

    		}

    	}

	}

    public void writeEndFeature()  throws Throwable{

    	try {

    		writer.endFeature();

    	} finally {

    		if (errorHandler.getErrorsSize() > 0) {

    			throw new Throwable(errorHandler.getErrorAt(0));

    		}

    	}

    }

    public void writeDataElement(List<DataElement> listData)  throws Throwable{

    	try {

    		for (DataElement de : listData) {

    			writer.startElement(de.getName(), (Object)de.getValue(), null); 

	    		writer.endElement();

    		}

    	} finally {

    		if (errorHandler.getErrorsSize() > 0) {

    			throw new Throwable(errorHandler.getErrorAt(0));

    		}

    	}

    } 

    public void writeEndGmlFile() throws Throwable{

    	try {

    		writer.endLayer();

    		writer.close();

    	} finally {

    		if (errorHandler.getErrorsSize() > 0) {

    			throw new Throwable(errorHandler.getErrorAt(0));

    		}

    	}

    }

    public File getFile() {

    	return writer.getOutputFile();

    }

}

package es.logex.callejero.core;

import java.util.List;

import es.logex.callejero.modelo.*;

public interface ILayer  {

	public BoundingBox getExtent();

	public void setExtent(BoundingBox box);

	public String getCrs();

	public void setCrs(String crs);

	public String getName();

	/**

	* @return la lista de las features.

	 */

	public List<Feature> getListFeature();

	public String getDescription();

	public void fillFromDb() throws Throwable;

	 ///public void setName(String name);

	//public Document getDocument();

	//	public void setExtent(BoundingBox box);

	//public void setListFeature(List<Feature> listFeature);

	public String getFileName();

	public void setFileName(String fileName) throws Throwable;

}

/**

 * 

 */

package es.logex.callejero.core;

import es.logex.callejero.modelo.*;

import java.util.*;

/**

 * @author kike

 *

 */

public interface IMap {

	/**

	 * Rellena todas las capas del mapa generando para cada una su documento gml.

	 * @throws Throwable 

	 */

	public void fillLayers() throws Throwable;

	/**

	 * Especifica el extent del mapa así como su crs.

	 * @param box

	 */

	public void setExtent(BoundingBox box);

	/**

	 * Recupera el box del mapa.

	 * @return

	 */

	public BoundingBox getExtent();

	/**

	 * Devuelve una lista de Layers

	 */

	public List<ILayer> getLayers();

}

package es.logex.callejero.core;

import java.util.List;

import es.logex.callejero.modelo.*;

public interface ICallejero {

	public List<String> getMunicipios();

	public  List<String> getMunicipiosLV(String municipio);

	public IMap getMapFromExtent(BoundingBox box);

}

/**

 * 

 */

package es.logex.callejero.core;

import java.awt.geom.Rectangle2D;

import java.io.File;

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;

import java.sql.SQLException;

import java.sql.Statement;

import java.util.ArrayList;

import java.util.List;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.postgis.PGbox2d;

import es.logex.callejero.modelo.BoundingBox;

import es.logex.callejero.modelo.DataElement;

import es.logex.callejero.modelo.Feature;

import es.logex.callejero.modelo.GeometryElement;

/**

 * @author kike

 * 

 */

public class LayerFile implements ILayer {

	private String name;

	private String description;

	private String fileName = "";

	protected Connection conn = null;

	private BoundingBox box;

	Log log = LogFactory.getLog(this.getClass());

	GMLProducer gmlProducer = null;

	private String crs;

	private String detailLevel = null;

	/*

	 * constructor a partir del nombre y el extent

	 */

	public LayerFile(String name, Connection conn, String inputDetailLevel, String outputPath) {

		log.info("Constructor LayerFile = " + name );

		// TODO: No hacer nada en el constructor. Implentar el patrón lazy, o

		// cargar la capa explícitamente

		this.conn = conn;

		this.name = name;

		this.detailLevel  = inputDetailLevel;

		gmlProducer = new GMLProducer(this,outputPath);

	}

	public BoundingBox getExtent() {

		return this.box;

	}

	public void setExtent(BoundingBox box) {

		this.box = box;

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see es.logex.callejero.core.ILayer#getName()

	 */

	public String getName() {

		return name;

	}

	public List<Feature> getListFeature() {

		return null;

	}

	/**

	 * Construye una lista con el nombre de los campos de una tabla

	 * 

	 * @param tabla

	 * @return su lista de campos

	 */

	@SuppressWarnings("unused")

	private List<String> getFieldsName(String tabla) throws Throwable {

		Statement st = null;

		ResultSet rs = null;

		// array with fields

		List<String> arrayFields = new ArrayList<String>();

		try {

			// To obtain the fields

			String query = "select * from " + tabla + " LIMIT 1;";

			st = conn.createStatement();

			log.debug("Se va a ejecutar la siguiente sentencia : \n" + query);

			rs = st.executeQuery(query);

			ResultSetMetaData rsmd = rs.getMetaData();

			for (int i = 0; i < arrayFields.size() + 1; i++) {

				if (!rsmd.getColumnName(i + 1).equalsIgnoreCase("the_geom")) {

					arrayFields.add(rsmd.getColumnName(i + 1));

				}

			}

		} catch (SQLException e) {

			log.error("Error obteniendo nombres de campos para la tabla "

					+ tabla);

			log.error(e.getMessage());

			throw e;

		}

		log.debug("Campos de la tabla/capa " + tabla);

		for (String s : arrayFields) {

			log.debug("\n " + s);

		}

		return arrayFields;

	}

	private String getSrsTable(String tableName) throws Exception {

		// se podría averiguar el srs de la tabla de dos formas.

		// 1. Consultando en la tabla geometry_elements

		// 2. consultando el srs de una geometría de la tabla, ya que todas van

		// a ser iguales.

		// Quizás esta segunda evita la posible "descoordinación" entre las dos

		// tablas.

		ResultSet r = null;

		Statement s = null;

		try {

			 s = conn.createStatement();

			String query = "SELECT SRID(the_geom) as srsTable FROM " + tableName + " LIMIT 1 ";

			 r = s.executeQuery(query);

			if ( r.next()) {

				return r.getString("srsTable");

			} else {

				throw new Exception("Las geometrías de la tabla " + tableName + " no tienen sistema de referencia");

			}

		}	finally {

            try {

               if (r != null)

            	   	r.close();

                if (s !=null)

                		s.close();

            } catch (SQLException e2) {

            	log.error("Error cerrando recordsets " + this.getName());

    			log.error(e2.getMessage());

    			throw e2;

            }

		}

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see es.logex.callejero.core.IDBFeatureExtractor#exec(es.logex.callejero.modelo.BoundingBox,

	 *      es.logex.callejero.core.ILayer)

	 */

	public File FromDbToFile(BoundingBox newExtent) throws Throwable {

		ResultSet r = null;

		ResultSetMetaData rmd = null;

		Statement s = null;

		String query = null;

		try {

			this.box = transformBBox(newExtent, this.name);

			s = conn.createStatement();

			String srsTable = getSrsTable(this.getName());

			//TODO: Afinar el comportamiento del detailLevel

			if (detailLevel.equalsIgnoreCase("SAMPLE")) { 

				//En el caso de detailLeve="SAMPLE" no restringimos por bbox la selección de elementos

				//y leemos el primer elemento que exista en la tabla. OJO!!!! y si no hay elementos en la tabla?

				//TODO: Crear un comportamiento razonable para cuando no haya elementos en la tabla.

				 query = "SELECT * FROM " + this.getName()  + "  LIMIT 1";

			} else {

				query = "SELECT * FROM " + this.getName() + " WHERE the_geom "

					+ " && TRANSFORM(SETSRID('BOX3D"

					+ newExtent.toString() + "'::box3d,"

					+newExtent.getSRID() + ")," + srsTable + ") ";

			}

			log.info("Preparado para ejecutar el query : " + query);

			r = s.executeQuery(query);

			rmd = r.getMetaData();

			log.debug("Se van a recuperar las features");

			gmlProducer.writeHeadGmlFile();

			while (r.next()) {

				List<DataElement> ldata = new ArrayList<DataElement>();

				GeometryElement geomElement = new GeometryElement();

				for (int t = 1; t <= rmd.getColumnCount(); t++) {

					String columnName = rmd.getColumnName(t);

					if (columnName.equals("the_geom")) {// TODO: Ojo,habría que

														// leer el nombre del

														// campo de la tabla de

														// geometry_columns.

						geomElement.setName(columnName);

						geomElement.setGeometry(r.getObject("the_geom"));

					} // TODO: En realidad una feature podría tener más de una

						// geometría asociada, habría que currárselo con una

						// lista(ya, un poco exagerado pero....).

					else {

						ldata.add(new DataElement(columnName, r

								.getString(columnName)));

					}

				}

				gmlProducer.writeStartFeature();

				if (ldata.size() > 0) {

					gmlProducer.writeDataElement(ldata);

				}

				if (geomElement != null) {

					gmlProducer.writeGeomElement(geomElement);

				}

				gmlProducer.writeEndFeature();

			}

			gmlProducer.writeEndGmlFile();

			return gmlProducer.getFile();

		} catch (SQLException sqle) {

			log.error("Error ejecutando sql\n " + query + "\n "

					+ " para la capa " + this.getName());

			log.error(sqle.getMessage());

			throw sqle;

		} finally {

			try {

				if (r != null)

					r.close();

				if (s != null)

					s.close();

			} catch (SQLException e2) {

				log.error("Error cerrando recordsets " + this.getName());

				log.error(e2.getMessage());

				throw e2;

			}

		}

	}

	private BoundingBox transformBBox(BoundingBox newExtent, String layerName) throws Exception {

		ResultSet r = null;

		Statement s = null;

		PGbox2d pgBox = null;

	    String srsTable;

		try {

			srsTable = getSrsTable(layerName);

			s = conn.createStatement();

			String query = "SELECT EXTENT(the_GEOM) as bbox FROM " + layerName + " where the_geom && TRANSFORM(SETSRID('BOX3D" + newExtent.toString() + "'::box3d,"+ newExtent.getSRID() + ")," + srsTable + ")";

			//String query = "SELECT EXTENT(the_geom) as bbox FROM municipios_geom where the_geom && SETSRID('BOX(626673.9375 4191040,815708.0625 4519371)'::box2d,23030)";

			log.debug("query transFormBBox : " + query);

			r = s.executeQuery(query);

		   if (r.next() )

			   pgBox = (PGbox2d) r.getObject("bbox");

		   else

			   return null;

		   Rectangle2D rec = null;

		   if (pgBox ==  null) {

			   rec =  new Rectangle2D.Double(0.0,0.0,0.0,0.0);

		   } else {

			   rec = new Rectangle2D.Double(pgBox.getLLB().x,pgBox.getLLB().y,

				   			pgBox.getURT().x-pgBox.getLLB().x, pgBox.getURT().y-pgBox.getLLB().y) ;

		   }

		   Double[] lowers = {rec.getMinX(), rec.getMinY()};

		   Double[] uppers = {rec.getMaxX(), rec.getMaxY()};

		   BoundingBox box = new BoundingBox(lowers, uppers, "EPSG:" + srsTable );

		   return box;

		} catch (SQLException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

			throw e;

		} finally {

			try {

				if (r != null)

					r.close();

				if (s != null)

					s.close();

			} catch (SQLException e2) {

				log.error("Error cerrando recordsets " + this.getName());

				log.error(e2.getMessage());

				throw e2;

			}

		}

	}

	public String getDescription() {

		return description;

	}

	public void setDescription(String description) {

		this.description = description;

	}

	public String getFileName() {

		return fileName;

	}

	public void setFileName(String fileName) {

		this.fileName = fileName;

	}

	public void fillFromDb() throws Throwable {

		// TODO Auto-generated method stub

		throw new Throwable("Método no implementado");

	}

	public String getCrs() {

		return this.crs;

	}

	public void setCrs(String crs) {

		this.crs = crs;

	}

}

package es.logex.utils;

public class LevenshteinElement implements Comparable<LevenshteinElement> {

		protected final int distance;

		protected final String name;

	   public LevenshteinElement(int distance, String name) {

	        this.distance = distance;

	        this.name = name;

	    }

	    public int compareTo(LevenshteinElement that) {

	        return (distance < that.distance) ? -1

	                : (distance > that.distance) ? 1

	                : 0;

	    }

	    public boolean equals(Object obj) {

	        return (obj instanceof LevenshteinElement) ? (compareTo((LevenshteinElement)obj) == 0) : false;

	    }

	    public int hashCode() {

	        return distance;

	    }

}

package es.logex.utils;

import java.util.*;

/**

 * Se llama Distancia de Levenshtein o distancia de edición el número mínimo de

 *  operaciones requeridas para transformar una cadena de caracteres en otra.

* Se entiende por operación, bien una inserción, eliminación o la substitución 

* de un carácter

 * @author kike

 */

public class LevenshteinDistance {

	static int maxDistance = 32000;

	private static int minimum(int a, int b, int c) {

	        if(a<=b && a<=c)

	            return a;

	        if(b<=a && b<=c)

	            return b;

	        return c;

	    }

	    public static int computeLevenshteinDistance(String str1, String str2) {

	        return computeLevenshteinDistance(str1.toCharArray(),

	                                          str2.toCharArray());

	    }

	    private static int computeLevenshteinDistance(char [] str1, char [] str2) {

	        int [][]distance = new int[str1.length+1][];

	        for(int i=0;i<=str1.length;i++)

	            {

	                distance[i]=new int[str2.length+1];

	                distance[i][0]=i;

	            }

	        for(int j=0;j<str2.length+1;j++)

	            distance[0][j]=j;

	        for(int i=1;i<=str1.length;i++)

	            for(int j=1;j<=str2.length;j++)

	                distance[i][j]= minimum(distance[i-1][j]+1,

	                                        distance[i][j-1]+1,

	                                        distance[i-1][j-1]+

	                                        ((str1[i-1]==str2[j-1])?0:1));

	        return distance[str1.length][str2.length];

	    }

	    /**

	     * Devuelve una lista con los 10 elementos de la lista más cercanos a la cadena

	     * de entrada.

	     * @param cadena

	     * @param lista

	     * @return

	     */

	    public   List<String> getTopX(String cadena, List<String> lista,int x) {

	    	List<String> outputList = new ArrayList<String>();

	    	if (cadena == null || lista == null ) {

	    		return outputList;

	    	}

	    	if (lista.isEmpty() || cadena.trim() == ""){

	    		return outputList;

	    	}

	    	if (x <= 0) {

	    		return outputList;

	    	}

	    	LevenshteinElement lve = new LevenshteinElement(maxDistance, "");

	    	LevenshteinElement[] outputArray = new LevenshteinElement[x];

	    	for (int i = 0; i < x; i++) {

	    		outputArray[i] = lve;

	    	}

	    	for (String s : lista){

	    		if (s.equalsIgnoreCase(cadena)) {

	    			outputList.clear();

	    			outputList.add(cadena);

	    			break;

	    		}

	    		LevenshteinElement lv = new LevenshteinElement(computeLevenshteinDistance(cadena.toUpperCase(), s.toUpperCase()),s.toUpperCase());

	  		    for (int i = 0; i < x ; i++) {

	  		    	if (lv.distance < outputArray[i].distance){

	  		    		outputArray[i] = lv;

	  		    		break;

	  		    	}

	  		    }

	  		}

	    	//Si no está vacía quiere decir que ha encontrado

	    	//la cadena exacta en la lista

	    	if (outputList.isEmpty()) {

	        	for (int i = 0; i < x; i++) {

		  			if (outputArray[i].name != null) {

		  				outputList.add(outputArray[i].name);

		  			}

		  	} 

	    	}

	        return outputList;

	    }

}

package es.logex.utils;

import java.util.List;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;