Application: gvSIG desktop » gvSIG data provider for GPE

public class ExportKMLPanels 

        extends AbstractExportPanels

        implements ExportPanels

    {

    ExportKMLPanels(

            ExportPanelsFactory factory, 

            JExportProcessPanel processPanel, 

            ExportParameters parameters

        ) {

        super(factory, processPanel, parameters);

        this.initPanels();

    }

    private void initPanels() {

        ExportPanelsManager manager = ExportSwingLocator.getExportPanelsManager();

        this.add( 

            new KMLPanel(

                this.getProcessPanel(), 

                this.getParameters()

            )

        );

        this.add(manager.createStandardPanel(

                ExportPanelsManager.PANEL_SELECT_OUTPUT_FILE,

                this.getProcessPanel(),

                this.getParameters()

        )

        );

    }

        this.parameters.setReprojectTo4326(this.getReprojectTo4326());

        gbc.gridx = 0;

        gbc.gridy = 2;

        gbc.gridwidth = 1;

        gridPanel.add(getReproCheckbox(offerReproj), gbc);

        gbc.gridx = 1;

        gbc.gridwidth = 5;

        JLabel rep_lbl = new JLabel(i18n.getTranslation(

            "kml_Force_to_EPSG_4326"));

        rep_lbl.setEnabled(offerReproj);

        gridPanel.add(rep_lbl, gbc);

    private boolean reprojectTo4326 = false;

    @Override

    public boolean getReprojectTo4326() {

        return this.reprojectTo4326;

    }

    public void setReprojectTo4326(boolean value) {

        this.reprojectTo4326 = value;

    }

    @Override

import org.gvsig.export.ExportLocator;

import org.gvsig.export.spi.AttributeNamesTranslator;

        ExportKMLParameters parameters = new ExportKMLParametersImpl();

    @Override

    public AttributeNamesTranslator createAttributeNamesTranslator() {

        return ExportLocator.getServiceManager().createAttributeNamesTranslator(10);

    }

import java.util.logging.Level;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

import org.gvsig.fmap.mapcontext.rendering.legend.ILegend;

import org.gvsig.tools.ToolsLocator;

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

        boolean reprojectTo4326 = this.getParameters().getReprojectTo4326();

        ArrayList<ICoordTrans> ICoordTrans;

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

        ICoordTrans ct = this.getParameters().getSourceTransformation(); //vlayer.getCoordTrans();

        IProjection targetproj;

        if (reprojectTo4326) {

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

                targetproj = this.getParameters().getSourceProjection();

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

        try {

            count = featureSet.getSize();

            this.getTaskStatus().setRangeOfValues(0, count);

            fldNames = getAttributes(featureStore.getDefaultFeatureType());

            //env = featureStore.getEnvelope();

            env = GeometryLocator.getGeometryManager().createEnvelope(Geometry.SUBTYPES.GEOM2D);

        } catch (Exception 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);

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

            wh.endLayer();

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

            wh.close();

            fos.close();

        } catch (Exception exc) {

            throw new ExportException(exc);

        }

        this.getTaskStatus().setCurValue(count);

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

            /*

             */

            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

        /*

         */

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

    }

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

        /*

         */

    }

    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;

        }

    }

        public boolean getReprojectTo4326();

        public void setReprojectTo4326(boolean value);