Application: gvSIG desktop » gvSIG data provider for GPE

<?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.45</version>

  </parent>

  <modules>

    <module>org.gvsig.gpe.exportto.kml</module>  

    <module>org.gvsig.gpe.exportto.generic</module>  

  </modules>

</project>

/**

 * 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 {

    }

}

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;

	}

}

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

	}

}

org.gvsig.gpe.exportto.generic.ExporttoGPEGenericLibrary

<?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.45</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>

/**

 * 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.kml;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.gvsig.exportto.ExporttoService;

import org.gvsig.exportto.swing.prov.file.AbstractExporttoFileProvider;

import org.gvsig.exportto.swing.spi.ExporttoSwingProvider;

import org.gvsig.exportto.swing.spi.ExporttoSwingProviderPanel;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;

import org.gvsig.gpe.exportto.kml.panel.KMLOptionsPanel;

import org.gvsig.tools.service.spi.ProviderServices;

/**

 * Exporto provider which gets Exporto from a file.

 *

 * @author gvSIG Team

 * @version $Id$

 */

public class ExporttoKMLProvider extends AbstractExporttoFileProvider implements

    ExporttoSwingProvider {

    private FLyrVect vectorLayer = null;

    private KMLOptionsPanel optPanel = null;

    /**

     *

     * Constructor.

     */

    public ExporttoKMLProvider(

        ProviderServices providerServices,

        FLyrVect vlayer) {

        super(

            providerServices,

            vlayer.getFeatureStore(),

            getTargetProjection(vlayer));

        vectorLayer = vlayer;

        IProjection viewProj = getTargetProjection(vlayer);

        boolean viewIs4326 = (viewProj.getAbrev().compareToIgnoreCase("epsg:4326") == 0);

        optPanel = new KMLOptionsPanel(vlayer.isLabeled(), !viewIs4326);

    }

    private static IProjection getTargetProjection(FLyrVect vlayer) {

        ICoordTrans ct = vlayer.getCoordTrans();

        if (ct == null) {

            return vlayer.getProjection();

        } else {

            return ct.getPDest();

        }

    }

    public ExporttoService createExporttoService() {

        return new ExporttoKMLService(

            selectFileOptionPanel.getSelectedFile(),

            featureStore,

            vectorLayer,

            optPanel.getLongFormat(),

            optPanel.useLabels(),

            optPanel.useBalloons(),

            optPanel.mustReprojectToEpsg4326());

    }

    public int getPanelCount() {

        return 2;

    }

    public ExporttoSwingProviderPanel getPanelAt(int index) {

        switch (index) {

        case 0:

            return optPanel;

        case 1:

            return selectFileOptionPanel;

        }

        return null;

    }

    @Override

    public boolean needsPanelTargetProjection(){

        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.kml;

import org.gvsig.exportto.swing.ExporttoSwingLibrary;

import org.gvsig.exportto.swing.spi.ExporttoSwingProviderLocator;

import org.gvsig.gpe.exportto.generic.ExporttoGPEGenericLibrary;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

import org.gvsig.tools.service.spi.ProviderManager;

/**

 * Library to initialize and register the file Exporto provider

 * implementation.

 * 

 * @author gvSIG Team

 * @version $Id$

 */

public class ExporttoKMLProviderLibrary extends AbstractLibrary {

    public void doRegistration() {

        registerAsServiceOf(ExporttoSwingLibrary.class);

        require(ExporttoGPEGenericLibrary.class);

    }

    protected void doInitialize() throws LibraryException {

        // Nothing to do

    }

    @Override

    protected void doPostInitialize() throws LibraryException {

        ProviderManager providerManager =

            ExporttoSwingProviderLocator.getManager();

        providerManager.addProviderFactory(new ExporttoKMLProviderFactory());

    }

}

/**

 * 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.kml;

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.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.exportto.ExporttoService;

import org.gvsig.exportto.ExporttoServiceException;

import org.gvsig.exportto.ExporttoServiceFinishAction;

import org.gvsig.exportto.swing.prov.file.AbstractExporttoFileService;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.exception.InitializeException;

import org.gvsig.fmap.dal.exception.ProviderNotRegisteredException;

import org.gvsig.fmap.dal.exception.ValidateDataParametersException;

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.FeatureStore;

import org.gvsig.fmap.dal.feature.FeatureType;

import org.gvsig.fmap.dal.feature.NewFeatureStoreParameters;

import org.gvsig.fmap.dal.spi.DataManagerProviderServices;

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.ILegend;

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.task.AbstractMonitorableTask;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.xmlpull.lib.api.stream.IXmlStreamWriter;

/**

 * @author gvSIG Team

 * @version $Id$

 *

 */

public class ExporttoKMLService extends AbstractMonitorableTask implements

    ExporttoService {

    private static Logger logger = LoggerFactory.getLogger(ExporttoKMLService.class);

    private FeatureStore featureStore = null;

    private FLyrVect vectorLayer = null;

    private List<ICoordTrans> transfList = new ArrayList<ICoordTrans>();

    private String mimeType = null;

    private File outFile = null;

    private boolean useLabels = false;

    private boolean attsAsBalloon = false;

    private boolean reprojectTo4326 = false;

    private IProjection targetproj = null;

    private NewFeatureStoreParameters newFeatureStoreParameters;

    private ExporttoServiceFinishAction exporttoServiceFinishAction;

    public ExporttoKMLService(

        File kmlFile,

        FeatureStore fstore,

        FLyrVect vlayer,

        String mtype,

        boolean doLabels,

        boolean balloon,

        boolean reproject4326) {

        super("Export to KML");

        outFile = kmlFile;

        featureStore = fstore;

        vectorLayer = vlayer;

        mimeType = mtype;

        useLabels = doLabels;

        attsAsBalloon = balloon;

        reprojectTo4326 = reproject4326;

        ICoordTrans ct = vlayer.getCoordTrans();

        if (reprojectTo4326) {

            targetproj = CRSFactory.getCRS("EPSG:4326");

            if (ct == null) {

                transfList.add(vlayer.getProjection().getCT(targetproj));

            } else {

                transfList.add(ct);

                transfList.add(ct.getPDest().getCT(targetproj));

            }

        } else {

            if (ct == null) {

                targetproj = vectorLayer.getProjection();

            } else {

                targetproj = ct.getPDest();

                transfList.add(ct);

            }

        }

    }

    public NewFeatureStoreParameters getNewFeatureStoreParameters() {

        return newFeatureStoreParameters;

    }

    public void addParameters(

        NewFeatureStoreParameters newFeatureStoreParameters) {

        newFeatureStoreParameters.setDynValue("CRS", targetproj);

    }

    public String getFileExtension() {

        return "kml";

    }

    public void export(FeatureSet featureSet) throws ExporttoServiceException {

        IGPEWriterHandler wh = null;

        FileOutputStream fos = null;

        String srs = targetproj.getAbrev();

        String[] fldNames = null;

        Envelope env = null;

        long count = 0;

        try {

            count = featureSet.getSize();

            this.taskStatus.setRangeOfValues(0, count);

            fldNames = getAttributes(featureStore.getDefaultFeatureType());

            env = this.featureStore.getEnvelope();

        } catch (DataException e) {

            throw new ExporttoServiceException(e);

        }

        try {

            env = reproject(env);

        } catch (CreateEnvelopeException cee) {

            throw new ExporttoServiceException(cee);

        }

        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) {

                symsty = StyleUtils.getSymbolStyles(

                    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 ============

            writeFeatures(wh, xmlw, featureSet, fldNames, symsty,

                (IVectorLegend) vectorLayer.getLegend());

            // ==========================================

            wh.endLayer();

            // ==========================================

            wh.close();

            fos.close();

        } catch (Exception exc) {

            throw new ExporttoServiceException(exc);

        }

        this.taskStatus.setCurValue(count);

        this.taskStatus.terminate();

        this.finishAction(fixedFile, this.targetproj);

    }

    private Envelope reproject(Envelope env) throws CreateEnvelopeException {

        int sz = transfList.size();

        if (sz == 0) {

            return env;

        } else {

            Envelope resp = env;

            try {

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

                    resp = resp.convert(transfList.get(i));

                }

            } catch (Exception exc) {

                // If this process fails, we'll use "emergency values":

                GeometryManager gm = GeometryLocator.getGeometryManager();

                double[] min = new double[2];

                double[] max = new double[2];

                if (targetproj.isProjected()) {

                    min = new double[]{-20000000, -20000000};

                    max = new double[]{ 20000000,  20000000};

                } else {

                    min = new double[]{-180, -90};

                    max = new double[]{ 180,  90};

                }

                resp = gm.createEnvelope(

                    min[0], min[1],

                    max[0], max[1],

                    Geometry.SUBTYPES.GEOM2D);

            }

            return resp;

        }

    }

    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 finishAction(File kmlfile, IProjection proj)

    throws ExporttoServiceException {

        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 ExporttoServiceException(

                    "Cannot add resulting kml file to view", e);

            }

            dsp.setDynValue("File", kmlfile);

            dsp.setDynValue("CRS", proj);

            try {

                dsp.validate();

            } catch (ValidateDataParametersException e) {

                throw new ExporttoServiceException(e);

            }

            exporttoServiceFinishAction.finished(kmlfile.getName(), dsp);

        }

    }

    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 void writeFeatures(

        IGPEWriterHandler gwh,

        IXmlStreamWriter xmlw,

        FeatureSet fset,

        String[] fieldNames,

        Map<ISymbol, KmlStyle> symsty,

        IVectorLegend lege) throws Exception {

        GeometryToGPEWriter gw = new GeometryToGPEWriter(gwh);

        DisposableIterator diter = fset.fastIterator();

        Feature feat = null;

        long count = 0;

        this.taskStatus.setCurValue(count);

        ISymbol sym = null;

        int nullGeometries = 0;

        while (diter.hasNext()) {

            feat = (Feature) diter.next();

            try {

                sym = lege.getSymbolByFeature(feat);

            } catch (MapContextException mce) {

                logger.info("While getting legend symbol.", mce);

            }

            if(!writeFeature(feat, gwh, xmlw, gw, count, fieldNames, symsty.get(sym))){

                nullGeometries++;

            };

            count++;

            this.taskStatus.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) throws IOException {

        Geometry geom = feat.getDefaultGeometry();

        if(geom == null){

            return false;

        }

        String strindex = String.valueOf(index);

        if (this.useLabels) {

            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.attsAsBalloon) {

            writeBalloon(xmlw, feat, fieldNames);

        }

        // ============= Geometry

        /*

         * This has no effect if reprojection is not necessary

         */

        geom = reproject(geom);

        gw.writeGeometry(geom, useLabels);

        // ============= 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 void writeBalloon(IXmlStreamWriter xmlw, Feature feat, String[] fieldNames)

    throws IOException {

        xmlw.writeStartElement(Kml2_1_Tags.EXTENDED_DATA);

        String fldrep = null;

        Object val = null;

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

            fldrep = fieldNames[i].replace(' ', '_');

            xmlw.writeStartElement(Kml2_1_Tags.DATA);

            // Att =====================================================

            xmlw.writeStartAttribute(null, "name");

            xmlw.writeValue(fldrep);

            xmlw.writeEndAttributes();

            // Value =====================================================

            xmlw.writeStartElement(Kml2_1_Tags.VALUE);

            val = feat.get(fieldNames[i]);

            xmlw.writeValue(val == null ? "" : val.toString());

            xmlw.writeEndElement();

            // =============================================

            xmlw.writeEndElement();

        }

        xmlw.writeEndElement();

        /*

         *

<ExtendedData>

      <Data name="holeNumber">

        <value>1</value>

      </Data>

      <Data name="holeYardage">

        <value>234</value>

      </Data>

      <Data name="holePar">

        <value>4</value>

      </Data>

    </ExtendedData>

         *

         */

    }

    private String getLabelForFeature(Feature feat) {

        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;

            }

        } else {

            return "";

        }

    }

    public void setFinishAction(

        ExporttoServiceFinishAction exporttoServiceFinishAction) {

        this.exporttoServiceFinishAction = exporttoServiceFinishAction;

    }

    private Geometry reproject(Geometry geom) {

        int sz = transfList.size();

        if (sz == 0) {

            return geom;

        } else {

            Geometry resp = geom.cloneGeometry();

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