/ - Diff - gvSIG data provider for GPE - gvSIG

     <?xml version="1.0" encoding="ISO-8859-1"?>
     <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
       <modelVersion>4.0.0</modelVersion>
       <artifactId>org.gvsig.gpe.exportto</artifactId>
       <packaging>pom</packaging>
       <parent>
           <groupId>org.gvsig</groupId>
           <artifactId>org.gvsig.gpe</artifactId>
           <version>2.1.164</version>
       </parent>
       <modules>
         <module>org.gvsig.gpe.exportto.kml</module>
         <module>org.gvsig.gpe.exportto.generic</module>
       </modules>
     </project>

org.gvsig.gpe/library/tags/org.gvsig.gpe-2.1.164/org.gvsig.gpe.exportto/org.gvsig.gpe.exportto.generic/src/main/resources/META-INF/services/org.gvsig.tools.library.Library
	1	org.gvsig.gpe.exportto.generic.ExporttoGPEGenericLibrary

     package org.gvsig.gpe.exportto.generic.util;
     import java.io.IOException;
     import org.gvsig.fmap.geom.primitive.Point;
     import org.gvsig.gpe.lib.api.parser.ICoordinateIterator;
     import org.gvsig.gpe.lib.api.writer.ICoordinateSequence;
     public class CoordinatesSequencePoint implements
     ICoordinateSequence, ICoordinateIterator {
     	double[] points = null;
     	int index = 0;
     	public CoordinatesSequencePoint(Point point) {
     	    if (point.getDimension() == 3) {
                 // 2dZ
     	        this.points = new double[3];
     	        points[0] = point.getX();
     	        points[1] = point.getY();
     	        points[2] = point.getCoordinateAt(2);
     	        index = 3;
     	    } else {
     	        // 2d
     	        this.points = new double[2];
     	        points[0] = point.getX();
     	        points[1] = point.getY();
     	        index = 2;
+    	    }
+    	}
     	public int getSize() {
     		return 1;
+    	}
     	public ICoordinateIterator iterator() {
     		return this;
+    	}
     	public int getDimension() {
     		return points.length;
+    	}
     	public boolean hasNext() throws IOException {
     		return (index > 0);
+    	}
     	public void next(double[] buffer) throws IOException {
     		buffer[0] = points[0];
     		buffer[1] = points[1];
     		if ((buffer.length == 3) && (points.length == 3)){
     			buffer[2] = points[2];
+    		}
     		index--;
+    	}
+    }

     package org.gvsig.gpe.exportto.generic.util;
     import java.awt.geom.Rectangle2D;
     import java.io.IOException;
     import org.gvsig.gpe.lib.api.parser.ICoordinateIterator;
     import org.gvsig.gpe.lib.api.writer.ICoordinateSequence;
     public class CoordinatesSequenceBbox implements
     ICoordinateSequence, ICoordinateIterator {
     	Rectangle2D bbox = null;
     	int index = 0;
     	public CoordinatesSequenceBbox(Rectangle2D bbox){
     		this.bbox = bbox;
+    	}
     	public int getSize() {
     		return 2;
+    	}
     	public ICoordinateIterator iterator() {
     		return this;
+    	}
     	public int getDimension() {
     		return 2;
+    	}
     	public boolean hasNext() throws IOException {
     		if (index <=1){
     			return true;
+    		}
     		return false;
+    	}
     	public void next(double[] buffer) throws IOException {
     		if (index == 0){
     			buffer[0] = bbox.getMinX();
     			buffer[1] = bbox.getMinY();
     		}else if (index == 1){
     			buffer[0] = bbox.getMaxX();
     			buffer[1] = bbox.getMaxY();
+    		}
     		index++;
+    	}
+    }

     package org.gvsig.gpe.exportto.generic.util;
     import java.awt.geom.PathIterator;
     import java.io.IOException;
     import org.gvsig.gpe.lib.api.parser.ICoordinateIterator;
     import org.gvsig.gpe.lib.api.writer.ICoordinateSequence;
     public class CoordinatesSequenceGeneralPath implements
     ICoordinateSequence, ICoordinateIterator {
     	private PathIterator it = null;
     	int size = 0;
     	boolean hasMoreGeoemtries = true;
     	public CoordinatesSequenceGeneralPath(PathIterator it) {
     		super();
     		this.it = it;
+    	}
     	public int getSize() {
     		return size;
+    	}
     	public void initialize(){
     		size = 0;
+    	}
     	public boolean hasMoreGeometries(){
     		return hasMoreGeoemtries;
+    	}
     	public ICoordinateIterator iterator() {
     		return this;
+    	}
     	public int getDimension() {
     		return 2;
+    	}
     	public boolean hasNext() throws IOException {
     		if (it.isDone()){
     			hasMoreGeoemtries = false;
     			return false;
+    		}
     		double[] coords = new double[2];
     		int type = it.currentSegment(coords);
     		/*
     		if (type == PathIterator.SEG_CLOSE){
     			hasMoreGeoemtries = false;
+    		}
     		*/
     		return ((type != PathIterator.SEG_MOVETO) || (size == 0));
+    	}
     	public void next(double[] buffer) throws IOException {
     		it.currentSegment(buffer);
     		it.next();
     		size++;
+    	}
+    }

     package org.gvsig.gpe.exportto.generic.util;
     import java.awt.geom.PathIterator;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     import org.gvsig.fmap.geom.Geometry;
     import org.gvsig.fmap.geom.GeometryLocator;
     import org.gvsig.fmap.geom.aggregate.MultiCurve;
     import org.gvsig.fmap.geom.aggregate.MultiPoint;
     import org.gvsig.fmap.geom.aggregate.MultiSurface;
     import org.gvsig.fmap.geom.exception.CreateGeometryException;
     import org.gvsig.fmap.geom.primitive.Curve;
     import org.gvsig.fmap.geom.primitive.Envelope;
     import org.gvsig.fmap.geom.primitive.Point;
     import org.gvsig.fmap.geom.primitive.Surface;
     import org.gvsig.gpe.lib.api.writer.IGPEWriterHandler;
     import org.gvsig.tools.locator.LocatorException;
     /**
+     *
      * Utility class to write gvSIG geometries in a GPE writer.
+     *
      * @author jldominguez (I have removed the reprojection methods/fields)
      */
     public class GeometryToGPEWriter {
         private static Logger logger = LoggerFactory.getLogger(GeometryToGPEWriter.class);
     	private IGPEWriterHandler writer = null;
     	//To know if the geometry is multiple
     	// private boolean isMultiple = false;
     	//To reproject geometries
     	/*
     	private IProjection projOrig = null;
     	private IProjection projDest = null;
     	private ICoordTrans coordTrans = null;
     	*/
     	private String srs = null;
     	public GeometryToGPEWriter(IGPEWriterHandler writer) {
     		this.writer = writer;
+    	}
         public String getCrs() {
             return srs;
+        }
         public void setCrs(String thesrs) {
             this.srs = thesrs;
+        }
         /**
     	 * It writes a geometry
     	 * @param geom
     	 * The geometry to write
     	 * @param crs
     	 * The coordinates reference system
     	 */
     	public void writeGeometry(Geometry geom, boolean addLabelPoint) {
     	    if (geom == null) {
     	        logger.error("GPE Writer cannot write geometry.",
     	            new Exception("Geometry is NULL"));
     	        return;
+    	    }
     	    // ====================================================
     		if (geom instanceof MultiPoint) {
     			writeMultiPoint((MultiPoint) geom);
     			return;
+    		}
             if (geom instanceof MultiCurve) {
                 writeMultiLine((MultiCurve) geom, addLabelPoint);
                 return;
+            }
             if (geom instanceof MultiSurface) {
                 writeMultiPolygon((MultiSurface) geom, addLabelPoint);
                 return;
+            }
             // ====================================================
             if (geom instanceof Point) {
                 writePoint((Point) geom);
                 return;
+            }
             if (geom instanceof Curve) {
                 writeLine((Curve) geom, addLabelPoint);
                 return;
+            }
             if (geom instanceof Surface) {
                 writePolygon((Surface) geom, addLabelPoint);
                 return;
+            }
             // ====================================================
             logger.error("GPE Writer cannot write geometry",
                 new Exception("Unexpected geometry: " + geom.getClass().getName()));
+    	}
     	/**
     	 * Writes a point in 2D
     	 * @param point
     	 * The point to write
     	 * @param crs
     	 * The coordinates reference system
     	 */
     	private void writePoint(Point point) {
     		writer.startPoint(null, new CoordinatesSequencePoint(point), srs);
     		writer.endPoint();
+    	}
     	/**
     	 * Writes a multipoint in 2D
     	 * @param point
     	 * The point to write
     	 * @param crs
     	 * The coordinates reference system
     	 */
     	private void writeMultiPoint(MultiPoint multi){
     		writer.startMultiPoint(null, srs);
     		for (int i=0 ; i<multi.getPrimitivesNumber() ; i++) {
     		    Point p = multi.getPointAt(i);
     			writePoint(p);
+    		}
     		writer.endMultiPoint();
+    	}
     	/**
     	 * Writes a line in 2D
     	 * @param line
     	 * The line to write
     	 * @param crs
     	 * The coordinates reference system
     	 * @param geometries
     	 * The parsed geometries
     	 */
     	private void writeLine(Curve curve, boolean addLabelPoint) {
     		boolean ismulti = isMultiple(curve.getPathIterator(null));
     		/*
              * Start ===================================================
              */
             if (addLabelPoint) {
                 Point po = null;
                 try {
                     po = getLabelPoint(curve.getPathIterator(null), curve.getEnvelope());
                 } catch (Exception ex) {
                     logger.info("While getting label point.", ex);
                     return;
+                }
                 writer.startMultiGeometry(null, srs);
                 CoordinatesSequencePoint pseq = new CoordinatesSequencePoint(po);
                 writer.startPoint(null, pseq, srs);
                 writer.endPoint();
             } else {
                 if (ismulti) {
                     writer.startMultiLineString(null, srs);
+                }
+            }
             /*
              * Body ===================================================
              */
             CoordinatesSequenceGeneralPath sequence =
     		    new CoordinatesSequenceGeneralPath(curve.getPathIterator(null));
     		writer.startLineString(null, sequence, srs);
     		writer.endLineString();
     		if (ismulti) {
     	        while (sequence.hasMoreGeometries()){
     	            sequence.initialize();
     	            writer.startLineString(null, sequence, srs);
     	            writer.endLineString();
+    	        }
+    		}
     		/*
              * End ===================================================
              */
     		if (addLabelPoint) {
                 writer.endMultiGeometry();
             } else {
                 if (ismulti) {
                     writer.endMultiLineString();
+                }
+            }
+    	}
         private void writeMultiLine(MultiCurve mcurve, boolean addLabelPoint) {
             if (addLabelPoint) {
                 Point po = null;
                 try {
                     po = getLabelPoint(mcurve.getPathIterator(null), mcurve.getEnvelope());
                 } catch (Exception exc) {
                     logger.info("While getting label point.", exc);
                     return;
+                }
                 writer.startMultiGeometry(null, srs);
                 CoordinatesSequencePoint pseq = new CoordinatesSequencePoint(po);
                 writer.startPoint(null, pseq, srs);
                 writer.endPoint();
             } else {
                 writer.startMultiLineString(null, srs);
+            }
             /*
              * Body =======================================
              */
             CoordinatesSequenceGeneralPath sequence =
                 new CoordinatesSequenceGeneralPath(mcurve.getPathIterator(null));
             writer.startLineString(null, sequence, srs);
             writer.endLineString();
             while (sequence.hasMoreGeometries()){
                 sequence.initialize();
                 writer.startLineString(null, sequence, srs);
                 writer.endLineString();
+            }
             /*
              * End ======================================
              */
             if (addLabelPoint) {
                 writer.endMultiGeometry();
             } else {
                 writer.endMultiLineString();
+            }
+        }
     	/**
     	 * Writes a polygon in 2D
     	 * @param polygon
     	 * The polygon to write
     	 * @param crs
     	 * The coordinates reference system
     	 * @param geometries
     	 * The parsed geometries
     	 */
     	private void writePolygon(Surface surface, boolean addLabelPoint) {
     	    boolean ismulti = isMultiple(surface.getPathIterator(null));
     	    CoordinatesSequenceGeneralPath sequence = null;
     	    /*
              * Start ===================================================
              */
     	    if (addLabelPoint) {
     	        Point po = null;
     	        try {
     	            po = surface.getInteriorPoint();
     	        } catch (Exception ex) {
     	            logger.info("While getting label point.", ex);
     	            return;
+    	        }
                 writer.startMultiGeometry(null, srs);
     	        CoordinatesSequencePoint pseq = new CoordinatesSequencePoint(po);
     	        writer.startPoint(null, pseq, srs);
     	        writer.endPoint();
     	    } else {
     	        if (ismulti) {
     	            writer.startMultiPolygon(null, srs);
+    	        }
+    	    }
     		/*
     		 * Body ===================================================
     		 */
     		sequence = new CoordinatesSequenceGeneralPath(surface.getPathIterator(null));
     		writer.startPolygon(null, sequence, srs);
     		writer.endPolygon();
             if (ismulti) {
                 while (sequence.hasMoreGeometries()){
                     sequence.initialize();
                     writer.startPolygon(null, sequence, srs);
                     writer.endPolygon();
+                }
+            }
             /*
              * End ===================================================
              */
     		if (addLabelPoint) {
     		    writer.endMultiGeometry();
     		} else {
     		    if (ismulti) {
     		        writer.endMultiPolygon();
+    		    }
+    		}
+    	}
         private Point getLabelPoint(PathIterator pathIterator, Envelope envelope) throws
         Exception {
             if (pathIterator == null || envelope == null) {
                 throw new Exception("Null iterator or envelope");
+            }
             double bestx = 0;
             double besty = 0;
             double cx = envelope.getCenter(0);
             double cy = envelope.getCenter(1);
             double dist = Double.MAX_VALUE;
             double auxdist = 0;
             double[] coords = new double[6];
             while (!pathIterator.isDone()) {
                 pathIterator.currentSegment(coords);
                 auxdist = getDist2(cx, cy, coords[0], coords[1]);
                 if (auxdist < dist) {
                     dist = auxdist;
                     bestx = coords[0];
                     besty = coords[1];
+                }
                 pathIterator.next();
+            }
             Point resp = GeometryLocator.getGeometryManager().createPoint(
                 bestx, besty, Geometry.SUBTYPES.GEOM2D);
             return resp;
+        }
         private Point getLabelPoint(MultiSurface msurf) throws Exception {
             if (msurf == null) {
                 throw new Exception("Surface is Null");
+            }
             int n = msurf.getPrimitivesNumber();
             Surface surf = null;
             Surface bigsurf = null;
             double importance = 0;
             double auximportance = 0;
             Envelope env = null;
             long nverts = 0;
             for (int i=0; i<n; i++) {
                 surf = (Surface) msurf.getPrimitiveAt(i);
                 nverts = surf.getNumVertices();
                 env = surf.getEnvelope();
                 auximportance = nverts * env.getLength(0) * env.getLength(1);
                 if (auximportance >= importance) {
                     importance = auximportance;
                     bigsurf = surf;
+                }
+            }
             if (bigsurf != null) {
                 return bigsurf.getInteriorPoint();
             } else {
                 return msurf.getInteriorPoint();
+            }
+        }
         /**
          * Returns (dist ^ 2) between points a and b
          * @param ax
          * @param ay
          * @param bx
          * @param by
          * @return
          */
         private double getDist2(
             double ax, double ay,
             double bx, double by) {
             double dx = bx - ax;
             double dy = by - ay;
             return (dx * dx) + (dy * dy);
+        }
         private void writeMultiPolygon(MultiSurface msurface, boolean addLabelPoint) {
             if (addLabelPoint) {
                 Point po = null;
                 try {
                     po = getLabelPoint(msurface);
                 } catch (Exception ex) {
                     logger.info("While getting label point.", ex);
                     return;
+                }
                 writer.startMultiGeometry(null, srs);
                 CoordinatesSequencePoint pseq = new CoordinatesSequencePoint(po);
                 writer.startPoint(null, pseq, srs);
                 writer.endPoint();
             } else {
                 writer.startMultiPolygon(null, srs);
+            }
             /*
              * Body ==============================================
              */
             CoordinatesSequenceGeneralPath sequence =
                 new CoordinatesSequenceGeneralPath(msurface.getPathIterator(null));
             writer.startPolygon(null, sequence, srs);
             writer.endPolygon();
             while (sequence.hasMoreGeometries()){
                 sequence.initialize();
                 writer.startPolygon(null, sequence, srs);
                 writer.endPolygon();
+            }
             /*
              * End ==============================================
              */
             if (addLabelPoint) {
                 writer.endMultiGeometry();
             } else {
                 writer.endMultiPolygon();
+            }
+        }
     	/**
     	 * Return if the geometry is multiple
     	 * @param path
     	 * @return
     	 */
     	public boolean isMultiple(PathIterator path){
     		double[] coords = new double[2];
     		int type = 0;
     		int numGeometries = 0;
     		while (!path.isDone()){
     			type = path.currentSegment(coords);
     			 switch (type) {
     			 	case PathIterator.SEG_MOVETO:
     			 		numGeometries++;
     			 		if (numGeometries == 2){
     			 			return true;
+    			 		}
     			 		break;
     			 	default:
     			 		break;
+    			 }
     			 path.next();
+    		}
     		return false;
+    	}
+    }

     /**
      * gvSIG. Desktop Geographic Information System.
+     *
      * Copyright (C) 2007-2013 gvSIG Association.
+     *
      * 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 3
      * 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., 51 Franklin Street, Fifth Floor, Boston,
      * MA  02110-1301, USA.
+     *
      * For any additional information, do not hesitate to contact us
      * at info AT gvsig.com, or visit our website www.gvsig.com.
      */
     package org.gvsig.gpe.exportto.generic;
     import org.gvsig.gpe.lib.api.GPELibrary;
     import org.gvsig.tools.library.AbstractLibrary;
     import org.gvsig.tools.library.LibraryException;
     /**
      * Library with common things to be used by
      * GPE export libraries
+     *
      * @author gvSIG Team
      * @version $Id$
      */
     public class ExporttoGPEGenericLibrary extends AbstractLibrary {
         public void doRegistration() {
             require(GPELibrary.class);
+        }
         protected void doInitialize() throws LibraryException {
             // Nothing to do
+        }
         protected void doPostInitialize() throws LibraryException {
+        }
+    }

     <?xml version="1.0" encoding="ISO-8859-1"?>
     <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
       <modelVersion>4.0.0</modelVersion>
       <artifactId>org.gvsig.gpe.exportto.generic</artifactId>
       <packaging>jar</packaging>
       <name>${project.artifactId}</name>
       <parent>
         <groupId>org.gvsig</groupId>
         <artifactId>org.gvsig.gpe.exportto</artifactId>
         <version>2.1.164</version>
       </parent>
       <dependencies>
         <dependency>
           <groupId>org.gvsig</groupId>
           <artifactId>org.gvsig.gpe.lib.api</artifactId>
           <scope>compile</scope>
         </dependency>
         <dependency>
             <groupId>org.gvsig</groupId>
             <artifactId>org.gvsig.tools.lib</artifactId>
             <scope>compile</scope>
         </dependency>
         <dependency>
             <groupId>org.gvsig</groupId>
             <artifactId>org.gvsig.fmap.geometry.api</artifactId>
             <scope>compile</scope>
         </dependency>
       </dependencies>
     </project>

     <?xml version="1.0" encoding="ISO-8859-1"?>
     <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
         <modelVersion>4.0.0</modelVersion>
         <artifactId>org.gvsig.gpe.exportto.kml</artifactId>
         <packaging>jar</packaging>
         <name>${project.artifactId}</name>
         <parent>
             <groupId>org.gvsig</groupId>
             <artifactId>org.gvsig.gpe.exportto</artifactId>
             <version>2.1.164</version>
         </parent>
         <dependencies>
             <dependency>
                 <groupId>org.gvsig</groupId>
                 <artifactId>org.gvsig.tools.swing.api</artifactId>
                 <scope>compile</scope>
             </dependency>
             <dependency>
                 <groupId>org.gvsig</groupId>
                 <artifactId>org.gvsig.tools.lib</artifactId>
                 <scope>compile</scope>
             </dependency>
             <dependency>
                 <groupId>org.gvsig</groupId>
                 <artifactId>org.gvsig.fmap.dal.api</artifactId>
                 <scope>compile</scope>
             </dependency>
             <dependency>
                 <groupId>org.gvsig</groupId>
                 <artifactId>org.gvsig.fmap.geometry.api</artifactId>
                 <scope>compile</scope>
             </dependency>
             <dependency>
                 <groupId>org.gvsig</groupId>
                 <artifactId>org.gvsig.fmap.mapcontext.api</artifactId>
                 <scope>compile</scope>
             </dependency>
             <dependency>
                 <groupId>org.gvsig</groupId>
                 <artifactId>org.gvsig.symbology.lib.api</artifactId>
                 <scope>compile</scope>
             </dependency>
             <dependency>
                 <groupId>org.gvsig</groupId>
                 <artifactId>org.gvsig.projection.api</artifactId>
                 <scope>compile</scope>
             </dependency>
             <dependency>
                 <groupId>org.gvsig</groupId>
                 <artifactId>org.gvsig.metadata.lib.basic.api</artifactId>
                 <scope>compile</scope>
             </dependency>
             <dependency>
                 <groupId>org.gvsig</groupId>
                 <artifactId>org.gvsig.exportto.lib.api</artifactId>
                 <scope>compile</scope>
             </dependency>
             <dependency>
                 <groupId>org.gvsig</groupId>
                 <artifactId>org.gvsig.exportto.swing.api</artifactId>
                 <scope>compile</scope>
             </dependency>
             <dependency>
                 <groupId>org.gvsig</groupId>
                 <artifactId>org.gvsig.gpe.lib.spi</artifactId>
                 <scope>compile</scope>
             </dependency>
             <dependency>
                 <groupId>org.gvsig</groupId>
                 <artifactId>org.gvsig.gpe.prov.kml</artifactId>
                 <scope>compile</scope>
             </dependency>
             <dependency>
                 <groupId>org.gvsig</groupId>
                 <artifactId>org.gvsig.gpe.exportto.generic</artifactId>
                 <scope>compile</scope>
             </dependency>
             <dependency>
                 <groupId>org.gvsig</groupId>
                 <artifactId>org.gvsig.fmap.dal.file.lib</artifactId>
                 <scope>compile</scope>
             </dependency>
         </dependencies>
             <properties>
             <gvsig.package.info.name>Export: KML</gvsig.package.info.name>
             <gvsig.package.info.state>testing</gvsig.package.info.state>
             <gvsig.package.info.categories>Formats,Vector</gvsig.package.info.categories>
             <gvsig.package.info.official>true</gvsig.package.info.official>
             <gvsig.package.info.dependencies>required: org.gvsig.app.mainplugin -ge 2</gvsig.package.info.dependencies>
             <gvsig.package.info.poolURL>https://devel.gvsig.org/download/projects/gvsig-gpe/pool</gvsig.package.info.poolURL>
         </properties>
     </project>

org.gvsig.gpe/library/tags/org.gvsig.gpe-2.1.164/org.gvsig.gpe.exportto/org.gvsig.gpe.exportto.kml/buildNumber.properties
	1	#Fri Dec 10 01:40:48 CET 2021
	2	buildNumber=2265

     <?xml version="1.0" encoding="ISO-8859-1"?>
     <plugin-config>
     	<depends plugin-name="org.gvsig.app.mainplugin" />
     	<depends plugin-name="org.gvsig.exportto.app.mainplugin" />
     	<depends plugin-name="org.gvsig.gpe.app.mainplugin" />
     	<libraries library-dir="lib"/>
     	<resourceBundle name="text"/>
     	<extensions>
     		<extension class-name="org.gvsig.andami.LibraryExtension"
     			description=""
     			active="true"
     			priority="1">
     		</extension>
     	</extensions>
     </plugin-config>

org.gvsig.gpe/library/tags/org.gvsig.gpe-2.1.164/org.gvsig.gpe.exportto/org.gvsig.gpe.exportto.kml/src/main/resources/META-INF/services/org.gvsig.tools.library.Library
	1	org.gvsig.gpe.exportto.kml.ExportKMLLibrary

     <!--
         gvSIG. Desktop Geographic Information System.
         Copyright (C) 2007-2013 gvSIG Association.
         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 3
         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., 51 Franklin Street, Fifth Floor, Boston,
         MA  02110-1301, USA.
         For any additional information, do not hesitate to contact us
         at info AT gvsig.com, or visit our website www.gvsig.com.
     -->
     <assembly>
       <id>gvsig-plugin-package</id>
       <formats>
         <format>zip</format>
       </formats>
       <baseDirectory>${project.artifactId}</baseDirectory>
       <includeBaseDirectory>true</includeBaseDirectory>
       <files>
         <file>
           <source>target/${project.artifactId}-${project.version}.jar</source>
           <outputDirectory>lib</outputDirectory>
         </file>
         <file>
           <source>target/package.info</source>
         </file>
       </files>
       <fileSets>
         <fileSet>
           <directory>src/main/resources-plugin</directory>
           <outputDirectory>.</outputDirectory>
         </fileSet>
       </fileSets>
       <dependencySets>
         <dependencySet>
           <useProjectArtifact>false</useProjectArtifact>
           <useTransitiveDependencies>false</useTransitiveDependencies>
           <outputDirectory>lib</outputDirectory>
           <includes>
             <include>org.gvsig:org.gvsig.gpe.exportto.generic</include>
           </includes>
         </dependencySet>
       </dependencySets>
     </assembly>

     /*
      * To change this license header, choose License Headers in Project Properties.
      * To change this template file, choose Tools | Templates
      * and open the template in the editor.
      */
     package org.gvsig.gpe.exportto.kml.service;
     import java.awt.geom.Rectangle2D;
     import java.io.File;
     import java.io.FileOutputStream;
     import java.io.IOException;
     import java.util.ArrayList;
     import java.util.Iterator;
     import java.util.List;
     import java.util.Map;
     import org.cresques.cts.ICoordTrans;
     import org.cresques.cts.IProjection;
     import org.gvsig.export.ExportException;
     import org.gvsig.export.ExportParameters;
     import org.gvsig.export.spi.AbstractExportService;
     import org.gvsig.export.spi.ExportService;
     import org.gvsig.export.spi.ExportServiceFactory;
     import org.gvsig.fmap.crs.CRSFactory;
     import org.gvsig.fmap.dal.DALLocator;
     import org.gvsig.fmap.dal.DataManager;
     import org.gvsig.fmap.dal.DataServerExplorer;
     import org.gvsig.fmap.dal.NewDataStoreParameters;
     import org.gvsig.fmap.dal.OpenDataStoreParameters;
     import org.gvsig.fmap.dal.exception.DataException;
     import org.gvsig.fmap.dal.feature.Feature;
     import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;
     import org.gvsig.fmap.dal.feature.FeatureSet;
     import org.gvsig.fmap.dal.feature.FeatureType;
     import org.gvsig.fmap.dal.feature.NewFeatureStoreParameters;
     import org.gvsig.fmap.dal.feature.OpenFeatureStoreParameters;
     import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorer;
     import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorerParameters;
     import org.gvsig.fmap.geom.DataTypes;
     import org.gvsig.fmap.geom.Geometry;
     import org.gvsig.fmap.geom.GeometryLocator;
     import org.gvsig.fmap.geom.GeometryManager;
     import org.gvsig.fmap.geom.exception.CreateEnvelopeException;
     import org.gvsig.fmap.geom.primitive.Envelope;
     import org.gvsig.fmap.mapcontext.MapContextException;
     import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;
     import org.gvsig.fmap.mapcontext.rendering.legend.IVectorLegend;
     import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;
     import org.gvsig.gpe.exportto.generic.util.CoordinatesSequenceBbox;
     import org.gvsig.gpe.exportto.generic.util.GeometryToGPEWriter;
     import org.gvsig.gpe.exportto.kml.style.KmlStyle;
     import org.gvsig.gpe.exportto.kml.style.StyleUtils;
     import org.gvsig.gpe.lib.api.GPELocator;
     import org.gvsig.gpe.lib.api.writer.IGPEWriterHandler;
     import org.gvsig.gpe.lib.api.writer.IGPEWriterHandlerImplementor;
     import org.gvsig.gpe.prov.kml.utils.Kml2_1_Tags;
     import org.gvsig.gpe.prov.kml.writer.GPEKmlWriterHandlerImplementor;
     import org.gvsig.tools.dispose.DisposableIterator;
     import org.gvsig.tools.locator.LocatorException;
     import org.gvsig.tools.util.HasAFile;
     import org.gvsig.xmlpull.lib.api.stream.IXmlStreamWriter;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     /**
+     *
      * @author osc
      */
     public class ExportKMLService extends AbstractExportService
     	implements ExportService {
     	private static Logger logger = LoggerFactory.getLogger(ExportKMLService.class);
     	ExportKMLService(ExportServiceFactory factory, ExportParameters parameters) {
     		super(factory, parameters);
+    	}
     	@Override
     	protected DataServerExplorer createServerExplorer() throws ExportException {
     		DataManager dataManager = DALLocator.getDataManager();
     		FilesystemServerExplorerParameters explorerParams;
     		try {
     			explorerParams
     				= (FilesystemServerExplorerParameters) dataManager
     					.createServerExplorerParameters(FilesystemServerExplorer.NAME);
     		} catch (Exception e) {
     			throw new ExportException(e);
+    		}
                     File parametersFile = getParameters().getEvaluatedFile();
     		explorerParams.setRoot(parametersFile.getParent());
     		FilesystemServerExplorer explorer;
     		try {
     			explorer = (FilesystemServerExplorer) dataManager.openServerExplorer(
     				"FilesystemExplorer", explorerParams
     			);
     			return explorer;
     		} catch (Exception e) {
     			throw new ExportException(e);
+    		}
+    	}
     	@Override
     	protected NewDataStoreParameters createTargetNewStoreParameters() throws ExportException {
     		try {
     			FilesystemServerExplorer explorer = (FilesystemServerExplorer) this.createServerExplorer();
     			NewFeatureStoreParameters newStoreParameters = (NewFeatureStoreParameters) explorer.getAddParameters(
     				"GPE"
     			);
                             ((HasAFile) newStoreParameters).setFile(this.getParameters().getEvaluatedFile());
     			newStoreParameters.setDynValue("CRS", this.getParameters().getTargetProjection());
     			// Usamos el featureType por defecto del KML
     			return newStoreParameters;
     		} catch (DataException ex) {
     			throw new ExportException(ex);
+    		}
+    	}
     	@Override
     	protected OpenDataStoreParameters createTargetOpenStoreParameters() throws ExportException {
     		try {
     			DataManager dataManager = DALLocator.getDataManager();
     			OpenFeatureStoreParameters openStoreParameters = (OpenFeatureStoreParameters) dataManager.createStoreParameters("GPE");
     			((HasAFile) openStoreParameters).setFile(getParameters().getEvaluatedFile());
     			openStoreParameters.setDynValue("CRS", this.getParameters().getTargetProjection());
     			return openStoreParameters;
     		} catch (DataException ex) {
     			throw new ExportException(ex);
+    		}
+    	}
     	@Override
     	public ExportKMLParameters getParameters() {
     		return (ExportKMLParameters) super.getParameters();
+    	}
     	@Override
     	public void export(
     		FeatureSet featureSet) throws ExportException {
     		DataServerExplorer explorer = this.createServerExplorer();
     		NewFeatureStoreParameters params = (NewFeatureStoreParameters) this.createTargetNewStoreParameters();
     		String providerName = params.getDataStoreName();
     		String explorerName = explorer.getProviderName();
     		File outFile = this.getParameters().getEvaluatedFile(); //kmlFile;
     		FeatureSet featureStore = featureSet;
     		FLyrVect vectorLayer = null;
     		String mimeType = this.getParameters().getMimeType(); //mtype;
     		boolean useLabels = this.getParameters().getUseLabels(); //doLabels;
     		boolean attsAsBalloon = this.getParameters().getAttsAsBalloon();
     		ArrayList<ICoordTrans> ICoordTrans;
     		List<ICoordTrans> transfList = new ArrayList<ICoordTrans>();
     		ICoordTrans ct = this.getParameters().getSourceTransformation(); //vlayer.getCoordTrans();
     		IProjection targetproj = this.getParameters().getTargetProjection();
     //        if (reprojectTo4326) {
     //		8
     //            targetproj = CRSFactory.getCRS("EPSG:4326");
     //            if (ct == null) {
     //                transfList.add(this.getParameters().getSourceProjection().getCT(targetproj));
     //            } else {
     //                transfList.add(ct);
     //                transfList.add(ct.getPDest().getCT(targetproj));
     //            }
     //        } else {
     		if (ct == null) {
     			if (targetproj == null) {
     				targetproj = this.getParameters().getSourceProjection();
+    			}
     			ct = this.getParameters().getSourceProjection().getCT(targetproj);
     			transfList.add(ct);
     		} else {
     			targetproj = ct.getPDest();
     			transfList.add(ct);
+    		}
     		IGPEWriterHandler wh = null;
     		FileOutputStream fos = null;
     		String srs = targetproj.getAbrev();
     		String[] fldNames = null;
     		Envelope env = null;
     		long count = 0;
     		FeatureType ftype;
     		try {
     			count = featureSet.getSize();
     			this.getTaskStatus().setRangeOfValues(0, count);
     			if (this.getParameters().getExportAttributes().isActive()) {
     				ftype = this.getParameters().getExportAttributes().getTargetFeatureType();
     			} else {
     				ftype = featureStore.getDefaultFeatureType();
+    			}
     			fldNames = getAttributes(ftype);
     			env = GeometryLocator.getGeometryManager().createEnvelope(Geometry.SUBTYPES.GEOM2D);
     			this.initEnvelope(env, featureSet);
     		} catch (DataException | CreateEnvelopeException | LocatorException e) {
     			throw new ExportException(e);
+    		}
     		try {
     			env = reproject(env, transfList);
     		} catch (CreateEnvelopeException ex) {
     			throw new ExportException(ex);
+    		}
     		Rectangle2D rect = new Rectangle2D.Double(
     			env.getMinimum(0),
     			env.getMinimum(1),
     			env.getLength(0),
     			env.getLength(1));
     		File fixedFile = outFile;
     		try {
     			if (!outFile.getAbsolutePath().toLowerCase().endsWith(
     				"." + this.getFileExtension().toLowerCase())) {
     				fixedFile = new File(outFile.getAbsolutePath() + "." + getFileExtension());
+    			}
     			wh = GPELocator.getGPEManager().createWriterByMimeType(mimeType);
     			fos = new FileOutputStream(fixedFile);
     			wh.setOutputStream(fos);
     			wh.initialize();
     			// ==========================================
     			wh.startLayer(null, null, fixedFile.getName(), null, srs);
     			// ==============     Styles    =============
     			Map<ISymbol, KmlStyle> symsty = null;
     			IXmlStreamWriter xmlw = getXmlStreamWriter(wh);
     			if (true && xmlw != null && vectorLayer instanceof FLyrVect) {
     				symsty = StyleUtils.getSymbolStyles((FLyrVect) vectorLayer,
     					featureSet,
     					attsAsBalloon,
     					fldNames);
     				Iterator<KmlStyle> iter = symsty.values().iterator();
     				KmlStyle sty = null;
     				while (iter.hasNext()) {
     					sty = iter.next();
     					writeStyle(xmlw, sty);
+    				}
+    			}
     			// ==========================================
     			wh.startBbox(null, new CoordinatesSequenceBbox(rect), srs);
     			wh.endBbox();
     			// ============= Writing feature ============
     			IVectorLegend legend;
     			if (vectorLayer instanceof FLyrVect) {
     				legend = (IVectorLegend) ((FLyrVect) vectorLayer).getLegend();
     			} else {
     				legend = null;
+    			}
     			writeFeatures(wh, xmlw, featureSet, fldNames, symsty, legend, transfList);
     //            writeFeatures(wh, xmlw, featureSet, fldNames, symsty,
     //                    (IVectorLegend) vectorLayer.getLegend());
     			// ==========================================
     			wh.endLayer();
     			// ==========================================
     			wh.close();
     			fos.close();
     		} catch (Exception exc) {
     			throw new ExportException(exc);
+    		}
     		this.getTaskStatus().setCurValue(count);
     //        this.finishAction(fixedFile, targetproj);
     		this.getTaskStatus().terminate();
     		this.getTaskStatus().remove();
+    	}
     	private String[] getAttributes(FeatureType ftype) {
     		FeatureAttributeDescriptor[] atts = ftype.getAttributeDescriptors();
     		FeatureAttributeDescriptor desc = null;
     		List<String> list = new ArrayList<String>();
     		for (int i = 0; i < atts.length; i++) {
     			desc = atts[i];
     			if (desc.getDataType().getType() != DataTypes.GEOMETRY) {
     				list.add(desc.getName());
+    			}
+    		}
     		return list.toArray(new String[0]);
+    	}
     	private Geometry reproject(Geometry geom, List<ICoordTrans> transfList) {
     		int sz = transfList.size();
     		if (sz == 0) {
     			return geom;
     		} else {
     			Geometry resp = geom.cloneGeometry();
     			for (int i = 0; i < sz; i++) {
     				resp.reProject(transfList.get(i));
+    			}
     			return resp;
+    		}
+    	}
     	public String getFileExtension() {
     		return "kml";
+    	}
     //    private void finishAction(File kmlfile, IProjection proj)
     //            throws ExportException {
     //
     //        this.createTargetOpenStoreParameters()
     //
     //        if (exporttoServiceFinishAction != null) {
     //
     //            /*
     //             * Export is done. We notify with a SHPStoreParameters,
     //             * not with the NewSHPParameters we have used:
     //             */
     //            DataManagerProviderServices dataman
     //                    = (DataManagerProviderServices) DALLocator.getDataManager();
     //
     //            DataStoreParameters dsp = null;
     //            try {
     //                dsp = dataman.createStoreParameters("GPE");
     //            } catch (Exception e) {
     //                throw new ExportException(e); //"Cannot add resulting kml file to view", e);
     //            }
     //
     //            dsp.setDynValue("File", kmlfile);
     //            dsp.setDynValue("CRS", proj);
     //
     //            try {
     //                dsp.validate();
     //            } catch (ValidateDataParametersException e) {
     //                throw new ExportException(e);
     //            }
     //            exporttoServiceFinishAction.finished(kmlfile.getName(), dsp);
     //        }
     //    }
     	private void writeStyle(IXmlStreamWriter xmlw, KmlStyle sty) throws IOException {
     		xmlw.writeStartElement(Kml2_1_Tags.STYLE);
     		xmlw.writeStartAttribute(Kml2_1_Tags.ID);
     		xmlw.writeValue(sty.getId());
     		xmlw.writeEndAttributes();
     		sty.writeXml(xmlw);
     		xmlw.writeEndElement();
+    	}
     	private IXmlStreamWriter getXmlStreamWriter(IGPEWriterHandler wh) {
     		IGPEWriterHandlerImplementor imple = wh.getImplementor();
     		if (!(imple instanceof GPEKmlWriterHandlerImplementor)) {
     			/*
                  * Unexpected class
     			 */
     			return null;
+    		}
     		GPEKmlWriterHandlerImplementor kmlimple = null;
     		kmlimple = (GPEKmlWriterHandlerImplementor) imple;
     		IXmlStreamWriter xmlw = kmlimple.getXMLStreamWriter();
     		return xmlw;
+    	}
     	private void writeFeatures(
     		IGPEWriterHandler gwh,
     		IXmlStreamWriter xmlw,
     		FeatureSet fset,
     		String[] fieldNames,
     		Map<ISymbol, KmlStyle> symsty,
     		IVectorLegend lege,
     		List<ICoordTrans> transfList) throws Exception {
     		GeometryToGPEWriter gw = new GeometryToGPEWriter(gwh);
     		DisposableIterator diter = fset.fastIterator();
     		Feature feat = null;
     		long count = 0;
     		this.getTaskStatus().setCurValue(count);
     		ISymbol sym = null;
     		int nullGeometries = 0;
     		while (diter.hasNext()) {
     			feat = (Feature) diter.next();
     			try {
     				if (lege instanceof IVectorLegend) {
     					sym = lege.getSymbolByFeature(feat);
+    				}
     			} catch (MapContextException mce) {
     				logger.info("While getting legend symbol.", mce);
+    			}
     			KmlStyle kmlStyle;
     			try {
     				kmlStyle = symsty.get(sym);
     			} catch (Exception e) {
     				kmlStyle = null;
+    			}
     			if (!writeFeature(feat, gwh, xmlw, gw, count, fieldNames, kmlStyle, transfList)) {
     				nullGeometries++;
     			};
     			count++;
     			this.getTaskStatus().setCurValue(count);
+    		}
     		if (nullGeometries > 0) {
     			logger.warn("Can't export " + nullGeometries + " features because source geometries are null.");
+    		}
     		diter.dispose();
+    	}
     	private boolean writeFeature(
     		Feature feat,
     		IGPEWriterHandler gwh,
     		IXmlStreamWriter xmlw,
     		GeometryToGPEWriter gw,
     		long index,
     		String[] fieldNames,
     		KmlStyle ksty,
     		List<ICoordTrans> transfList) throws IOException {
     		Geometry geom = feat.getDefaultGeometry();
     		if (geom == null) {
     			return false;
+    		}
     		String strindex = String.valueOf(index);
     		if (this.getParameters().getUseLabels()) {
     			String lbl = getLabelForFeature(feat);
     			gwh.startFeature(strindex, "FEATURE", lbl);
     		} else {
     			gwh.startFeature(strindex, "FEATURE", "");
+    		}
     		// =========================
     		// Style
     		if (ksty != null) {
     			xmlw.writeStartElement(Kml2_1_Tags.STYLEURL);
     			xmlw.writeValue("#" + ksty.getId());
     			xmlw.writeEndElement();
+    		}
     		// ===== Balloon ============
     		if (this.getParameters().getAttsAsBalloon()) {
     			writeBalloon(xmlw, feat, fieldNames);
+    		}
     		// ============= Geometry
     		/*
              * This has no effect if reprojection is not necessary
     		 */
     		geom = reproject(geom, transfList);
     		gw.writeGeometry(geom, this.getParameters().getUseLabels());
     		// ============= Attributes
     		Object val = null;
     		String fldname = null;
     		for (int i = 0; i < fieldNames.length; i++) {
     			val = feat.get(fieldNames[i]);
     			fldname = fieldNames[i].replace(' ', '_');
     			gwh.startElement("", fldname, val == null ? "" : val.toString());
     			gwh.endElement();
+    		}
     		// =========================
     		gwh.endFeature();
     		return true;
+    	}
     	private String getLabelForFeature(Feature feat) {
     		return "";
     //        if (this.vectorLayer.isLabeled()) {
     //
     //            String[] flds = vectorLayer.getLabelingStrategy().getUsedFields();
     //            int n = Math.min(flds.length, 2);
     //            if (n == 0) {
     //                return "";
     //            } else {
     //                String resp = "";
     //                Object val = null;
     //                if (n == 1) {
     //                    val = feat.get(flds[0]);
     //                    resp = (val == null) ? "" : val.toString();
     //                } else {
     //                    // n == 2
     //                    val = feat.get(flds[0]);
     //                    resp = (val == null) ? "" : val.toString();
     //                    val = feat.get(flds[1]);
     //                    resp = (val == null) ? resp : resp + ", " + val.toString();
     //                }
     //                return resp;
     //            }
     //

Application: gvSIG desktop » gvSIG data provider for GPE

Revision 1533