Application: gvSIG desktop » gvSIG data providers based on gdal

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2016 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 2

 * 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.gdal.prov.gml;

import java.io.File;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.Vector;

import org.apache.commons.io.FileUtils;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.ICRSFactory;

import org.cresques.cts.IProjection;

import org.gdal.gdal.gdal;

import org.gdal.ogr.DataSource;

import org.gdal.ogr.Driver;

import org.gdal.ogr.FeatureDefn;

import org.gdal.ogr.FieldDefn;

import org.gdal.ogr.GeomFieldDefn;

import org.gdal.ogr.Layer;

import org.gdal.ogr.ogr;

import org.gdal.ogr.ogrConstants;

import org.gdal.osr.SpatialReference;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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

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

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

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

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.spi.FeatureProvider;

import org.gvsig.fmap.dal.resource.spi.ResourceProvider;

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

import org.gvsig.fmap.geom.type.GeometryType;

import org.gvsig.gdal.prov.ogr.OGRConverter;

import org.gvsig.gdal.prov.ogr.OGRDataStoreProvider;

import org.gvsig.gdal.prov.ogr.OGRUnsupportedFormatException;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.exception.BaseException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * @author <a href="mailto:lmarques@disid.com">Lluis Marques</a>

 *

 */

public class GMLDataStoreProvider extends OGRDataStoreProvider {

    private static final Logger LOG = LoggerFactory.getLogger(GMLDataStoreProvider.class);

    /**

     *

     */

    public static final String NAME = "GMLDataStoreProvider";

    /**

     *

     */

    public static final String DESCRIPTION = "GML provider to open vectorial resources";

    protected GMLDataStoreProvider(DataStoreParameters dataParameters,

        DataStoreProviderServices storeServices, DynObject metadata) throws InitializeException {

        super(dataParameters, storeServices, metadata);

    }

    protected GMLDataStoreProvider(DataStoreParameters dataParameters,

        DataStoreProviderServices storeServices) throws InitializeException {

        super(dataParameters, storeServices);

    }

    @Override

    protected synchronized DataSource getDataSource() throws OGRUnsupportedFormatException {

        try {

            if (this.dataSource == null) {

                if (getGMLParameters().getXsdSchema() != null

                    && StringUtils.isBlank(getGMLParameters().getConnectionString())) {

                    StringBuilder stb = new StringBuilder();

                    if (StringUtils.isBlank(getGMLParameters().getConnectionString())

                        && getGMLParameters().getFile() != null) {

                        stb.append(getGMLParameters().getFile().getAbsolutePath());

                    } else if (StringUtils.isNotBlank(getGMLParameters().getConnectionString())) {

                        stb.append(getGMLParameters().getConnectionString());

                    }

                    stb.append(",xsd=");

                    stb.append(getGMLParameters().getXsdSchema());

                    getGMLParameters().setConnectionString(stb.toString());

                }

                if (getGMLParameters().getGfsSchema() != null) {

                    gdal.SetConfigOption("GML_GFS_TEMPLATE", getGMLParameters().getGfsSchema()

                        .getAbsolutePath());

                }

            }

            return super.getDataSource();

        } finally {

            gdal.SetConfigOption("GML_GFS_TEMPLATE", null);

        }

    }

    private GMLDataStoreParameters getGMLParameters() {

        return (GMLDataStoreParameters) this.getParameters();

    }

    @Override

    public boolean allowWrite() {

        return true;

    }

    @SuppressWarnings("rawtypes")

    @Override

    public void performChanges(Iterator deleteds, Iterator inserteds, Iterator updateds,

        Iterator featureTypesChanged) throws DataException {

        FeatureStore store = this.getStoreServices().getFeatureStore();

        FeatureType defaultFeatureType = store.getDefaultFeatureType();

        String baseName = FilenameUtils.getBaseName(getGMLParameters().getFile().getName());

        File newFile = null;

        File newSchemaFile = null;

        try {

            newFile = File.createTempFile(baseName, null);

            newSchemaFile = getSchemaFile(newFile);

        } catch (IOException e) {

            String msg = String.format("Temp %1s file", new Object[] { baseName });

            throw new CreateException(msg, e);

        }

        Driver driver = ogr.GetDriverByName("GML");

        Vector<String> options = new Vector<String>(1);

        options.add("FORMAT=GML3.2");

        DataSource newDataSource = driver.CreateDataSource(newFile.getAbsolutePath(), options);

        // Copy other layer to new data source

        OGRConverter converter = new OGRConverter();

        for (int i = 0; i < getDataSource().GetLayerCount(); i++) {

            Layer tmpLayer = getDataSource().GetLayerByIndex(i);

            if (tmpLayer.GetName().equals(getGMLParameters().getLayerName())) {

                continue;

            }

            SpatialReference srs = tmpLayer.GetSpatialRef();

            int ogrGeomType = tmpLayer.GetGeomType();

            List<FieldDefn> fields = new ArrayList<FieldDefn>();

            FeatureDefn layerDefn = tmpLayer.GetLayerDefn();

            for (int j = 0; j < layerDefn.GetFieldCount(); j++) {

                fields.add(layerDefn.GetFieldDefn(j));

            }

            List<GeomFieldDefn> geomFields = new ArrayList<GeomFieldDefn>();

            for (int j = 0; j < layerDefn.GetGeomFieldCount(); j++) {

                geomFields.add(layerDefn.GetGeomFieldDefn(j));

            }

            List<org.gdal.ogr.Feature> ogrFeatures = new ArrayList<org.gdal.ogr.Feature>();

            org.gdal.ogr.Feature feature = tmpLayer.GetNextFeature();

            while(feature!=null){

                ogrFeatures.add(feature);

            }

            createLayer(newDataSource, tmpLayer.GetName(), srs, ogrGeomType, fields, geomFields,

                ogrFeatures);

        }

        SpatialReference srs = getLayer().GetSpatialRef();

        if (srs == null) {

            IProjection projection = defaultFeatureType.getDefaultSRS();

            if (projection == null) {

                projection = (IProjection) this.getDynValue(DataStore.METADATA_CRS);

                if (projection != null) {

                    srs = new SpatialReference(projection.export(ICRSFactory.FORMAT_WKT));

                }

            }

        }

        int ogrGeomType = -1;

        GeometryType geomType = defaultFeatureType.getDefaultGeometryAttribute().getGeomType();

        if (geomType != null) {

            ogrGeomType = converter.convertToOGRGeomType(geomType.getType());

        }

        List<FieldDefn> fields = converter.convertFields(defaultFeatureType);

        List<GeomFieldDefn> geomFields = converter.convertGeometryFields(defaultFeatureType, true);

        FeatureSet featureSet = getFeatureStore().getFeatureSet();

        createLayer(newDataSource, getLayer().GetName(), srs, ogrGeomType, fields, geomFields,

            featureSet);

        // Release native resources to close file.

        newDataSource.delete();

        // Close current file

        getResource().removeConsumer(this);

        getResource().closeRequest();

        // Delete current file

        if (getGMLParameters().getFile().delete()) {

            try {

                FileUtils.copyFile(newFile, getGMLParameters().getFile());

                FileUtils.copyFile(newSchemaFile, getSchemaFile(getGMLParameters().getFile()));

            } catch (IOException e) {

                throw new CopyException(newFile.getName(), e);

            }

        }

        this.resourceProvider = null;

        getResource().addConsumer(this);

        getResource().notifyChanges();

    }

    private Layer createLayer(DataSource dataSource, String layerName, SpatialReference srs,

        int ogrGeomType, List<FieldDefn> fields, List<GeomFieldDefn> geomFields,

        FeatureSet featureSet) throws DataException {

        Layer newLayer = createLayer(dataSource, layerName, srs, ogrGeomType, fields, geomFields);

        OGRConverter converter = new OGRConverter();

        DisposableIterator iterator = featureSet.fastIterator();

        try {

            while (iterator.hasNext()) {

                Feature feature = (Feature) iterator.next();

                FeatureProvider featureProvider =

                    getStoreServices().getFeatureProviderFromFeature(feature);

                org.gdal.ogr.Feature orgFeature = converter.convert(featureProvider);

                newLayer.CreateFeature(orgFeature);

            }

        } catch (BaseException e) {

            LOG.error("Can not convert featureProvider to OGR Feature", e);

            throw new WriteException(newLayer.GetName(), e);

        } finally {

            iterator.dispose();

        }

        return newLayer;

    }

    private Layer createLayer(DataSource dataSource, String layerName, SpatialReference srs,

        int ogrGeomType, List<FieldDefn> fields, List<GeomFieldDefn> geomFields,

        List<org.gdal.ogr.Feature> ogrFeatures) throws DataException {

        Layer newLayer = createLayer(dataSource, layerName, srs, ogrGeomType, fields, geomFields);

        OGRConverter converter = new OGRConverter();

        // Save features to new layer

        for (org.gdal.ogr.Feature feature : ogrFeatures) {

            org.gdal.ogr.Feature fixedFeature = converter.convert(newLayer.GetLayerDefn(), feature);

            newLayer.CreateFeature(fixedFeature);

        }

        return newLayer;

    }

    private Layer createLayer(DataSource dataSource, String layerName, SpatialReference srs,

        int ogrGeomType, List<FieldDefn> fields, List<GeomFieldDefn> geomFields) {

        Layer newLayer = null;

        // Create new layer

        if (srs == null) {

            newLayer = dataSource.CreateLayer(layerName);

        } else if (ogrGeomType == -1) {

            newLayer = dataSource.CreateLayer(layerName, srs);

        } else {

            newLayer = dataSource.CreateLayer(layerName, srs, ogrGeomType);

        }

        // Creating fields

        if (newLayer.TestCapability(ogrConstants.OLCCreateField)) {

            for (FieldDefn fieldDefn : fields) {

                newLayer.CreateField(fieldDefn);

            }

        } else {

            LOG.warn("{} driver does not support creation of fields", dataSource.GetDriver()

                .getName());

        }

        // Creating geometry fields

        if (newLayer.TestCapability(ogrConstants.OLCCreateGeomField)) {

            for (GeomFieldDefn geomFieldDefn : geomFields) {

                newLayer.CreateGeomField(geomFieldDefn);

            }

        } else {

            LOG.warn("{} driver does not support creation of geometry fields, only default"

                + " OGR geometry field has been created", dataSource.GetDriver().getName());

        }

        return newLayer;

    }

    private File getSchemaFile(File newFile) {

        String baseName = FilenameUtils.getBaseName(newFile.getName());

        File xsdFiel = new File(newFile.getParentFile(), baseName + ".xsd");

        return xsdFiel;

    }

    public void resourceChanged(ResourceProvider resource) {

        if (getGMLParameters().getXsdSchema() == null) {

            File schemaFile = getSchemaFile(getGMLParameters().getFile());

            if(schemaFile.exists()){

                getGMLParameters().setXsdSchema(schemaFile);

            } else {

                getGMLParameters().setXsdSchema(null);

            }

        }

        FeatureStore store = this.getStoreServices().getFeatureStore();

        FeatureType defaultFeatureType = null;

        try {

            defaultFeatureType = store.getDefaultFeatureType();

            getGMLParameters().setDefaultGeometryField(

                defaultFeatureType.getDefaultGeometryAttributeName());

        } catch (DataException e) {

            LOG.error("Can not default featury type of {}", this.getName());

            return;

        }

        super.resourceChanged(resource);

    }

}