| gvSIG desktop 1

/**

 * 

 */

package es.logex.callejero.core;

import java.io.File;

import java.util.List;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.gvsig.gpe.GPEContentHandler;

import org.gvsig.gpe.GPEDefaults;

import org.gvsig.gpe.GPEErrorHandler;

import org.gvsig.gpe.GPEParser;

import org.gvsig.gpe.GPERegister;

import org.gvsig.gpe.writers.GPEWriterHandler;

import org.gvsig.gpe.gml.writer.GPEGmlWriterHandlerImplementor;

//import org.gvsig.gpe.writers.IGPEWriterHandler;

import es.logex.callejero.modelo.*;

import es.logex.callejero.exceptions.*;

import es.logex.utils.*;

import org.gvsig.gpe.*;

import org.postgis.PGgeometry;

import org.postgis.Geometry;

import org.postgis.LinearRing;

import org.postgis.LineString;

import org.postgis.MultiLineString;

import org.postgis.MultiPoint;

import org.postgis.MultiPolygon;

import org.postgis.Polygon;

import org.postgis.Point;

import com.vividsolutions.jts.geom.*;

import com.vividsolutions.jts.io.*;

import org.w3c.dom.Document;

import org.tigris.frogs.commons.*;

/**

 * @author kike

 *

 */

public class GMLProducer implements IGMLProducer{

        /*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 String schema = "";

        private GPEWriterHandler writer = null;

        private String writerName = "GML writer";

        private GPEErrorHandler errorHandler;

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

        public GMLProducer(){

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

                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.GPEGmlWriterHandlerImplementor.class);

                        //Gets the writer

                        writer = GPERegister.createWriter(writerName);        

                        errorHandler = new CallejeroGPEErrorHandler();

                        writer.setErrorHandler(errorHandler);

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

                } catch (Exception e){

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

                        log.error(e.getMessage());

                }

        }

        /**

         * Genera un archivo gml con tantos featuresMembers como features de la capa .

         */

        public  String toGml(ILayer layer) {

                //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();

                log.debug("Writer inicializado");

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

                log.debug("Capa inicializada");

                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();

                log.debug("BoundedBy escrito");

                int i = 0;

                for (Feature f : layer.getListFeature()) {

                        i += 1;

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

                        log.debug("Start feature");

                        //todos sus atributos

                        for (DataElement de : f.getData()) {

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

                                writer.endElement();

                                //TODO: coger el type cuando se rellena la feature

                        }

                        log.debug("Escritos los dataElements de la feauture");

//                        la geometría

                        GeometryElement ge = f.getGeometryElement();

                        PGgeometry geom = f.getGeometryElement().getGeometry();

                        if (ge != null) {

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

                                switch (geom.getGeoType()) {

                                        case Geometry.MULTIPOLYGON:

                                                log.debug("la geometría es Multipoligono");

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

                                                writer.startMultiPolygon(Integer.toString(i), box.getCrsBoundingBox());

                                                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, box.getCrsBoundingBox());

                                                        writer.endPolygon();

                                                }

                                                writer.endMultiPolygon();

                                                writer.endElement();

                                                writer.endFeature();

                                                log.debug("End Feature");

                                                break;

                                        case Geometry.MULTILINESTRING:

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

                                                writer.startMultiLineString(Integer.toString(i), box.getCrsBoundingBox());

                                                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, box.getCrsBoundingBox());

                                                    writer.endLineString();

                                                }

                                                writer.endMultiLineString();

                                                writer.endElement();

                                                writer.endFeature();

                                                break;

                                        case Geometry.POINT:

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

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

                                            writer.endPoint();

                                                writer.endElement();

                                                writer.endFeature();

                                                break;

                                        default:

                                                break;

                                }

                        }

                        if (errorHandler.getErrorsSize() > 0) {

                        for (int j = 0; j < errorHandler.getErrorsSize(); j++) {

                                log.error(errorHandler.getErrorAt(j));

                        }

                }

                if (errorHandler.getWarningsSize() > 0) {

                        for (int k = 0; k < errorHandler.getErrorsSize(); k++) {

                                log.warn(errorHandler.getErrorAt(k));

                        }

                }

                }

                writer.endLayer();

                log.debug("End layer");

                writer.close();

                log.debug("Cerramos el writer (flush)");

                //return Xml.readXmlDocument(writer.getFileName(),false);

                return writer.getFileName();

        }

}