Application: gvSIG desktop » gvSIG data provider for GPE

/*

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

                }

                explorerParams.setRoot(this.getParameters().getFile().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(

                                this.getParameters().getFile()

                        );

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

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

//            }

//

//        } else {

//            return "";

//        }

        }

        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 Envelope reproject(Envelope env, List<ICoordTrans> transfList) 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];

                                IProjection targetproj = this.getParameters().getTargetProjection();

                                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 initEnvelope(Envelope env, FeatureSet featureSet) {

                for (Feature feature : featureSet) {

                        Geometry geometry = feature.getDefaultGeometry();

                        if (geometry != null && geometry.isValid()) {

                                env.add(geometry);

                        }

                }

        }

}