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

import java.util.ArrayList;

import java.util.Calendar;

import java.util.Date;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.ICRSFactory;

import org.cresques.cts.IProjection;

import org.gdal.ogr.DataSource;

import org.gdal.ogr.Feature;

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.crs.CRSFactory;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataTypes;

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

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

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

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

import org.gvsig.fmap.dal.feature.spi.DefaultFeatureProvider;

import org.gvsig.fmap.dal.feature.spi.FeatureProvider;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.Geometry.TYPES;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.operation.GeometryOperationException;

import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;

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

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

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

import org.gvsig.tools.exception.BaseException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Converter class used to parse OGR layer defn, feature, types... to gvSIG

 * objects and constant.

 *

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

 *

 */

public class OGRConverter {

    /**

     * Default geometry column name used when the geometry column of layer does

     * not have name. This is necessary to create FeatureType and it must take

     * into account when feature geometry is requested.

     */

    private final String DEFAULT_GEOMETRY_COLUMN_NAME = "ogr_geometry";

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

    /**

     *

     */

    public OGRConverter() {

    }

    /**

     * Converts {@link FeatureDefn} to {@link FeatureType} and sets

     * default geometry field to created {@link FeatureType}.

     *

     * @param featureDefn

     *            OGR definition to be converted

     * @param defaultGeometryField

     *            Default geometry field. If it is not founded, this method will

     *            take the first geometry field.

     * @return FeatureType Feature type equivalent

     * @throws GeometryTypeNotSupportedException

     *             If there are problems parsing OGR geometry

     * @throws GeometryTypeNotValidException

     *             If type of OGR Geometry is not supported

     */

    public FeatureType convert(FeatureDefn featureDefn, String defaultGeometryField)

        throws GeometryTypeNotSupportedException, GeometryTypeNotValidException {

        EditableFeatureType editableFeatureType = DALLocator.getDataManager().createFeatureType();

        editableFeatureType.setHasOID(true);

        for (int i = 0; i < featureDefn.GetFieldCount(); i++) {

            FieldDefn fieldDefn = featureDefn.GetFieldDefn(i);

            EditableFeatureAttributeDescriptor attributeDescriptor =

                editableFeatureType.add(fieldDefn.GetName(),

                    this.convertToDataType(fieldDefn.GetFieldType()));

            attributeDescriptor.setPrecision(fieldDefn.GetPrecision());

        }

        for (int i = 0; i < featureDefn.GetGeomFieldCount(); i++) {

            GeomFieldDefn geomFieldDefn = featureDefn.GetGeomFieldDefn(i);

            String name = null;

            if (StringUtils.isBlank(geomFieldDefn.GetName())) {

                // Set default geometry column name

                name = DEFAULT_GEOMETRY_COLUMN_NAME;

            } else {

                name = geomFieldDefn.GetName();

            }

            EditableFeatureAttributeDescriptor attributeDescriptor =

                editableFeatureType.add(name, DataTypes.GEOMETRY);

            // GDAL 1.11.2 Only supports 2D geometries

            GeometryManager geometryManager = GeometryLocator.getGeometryManager();

            GeometryType geometryType =

                geometryManager.getGeometryType(

                    this.convertToGeomType(geomFieldDefn.GetFieldType()), SUBTYPES.GEOM2D);

            attributeDescriptor.setGeometryType(geometryType);

            if (geomFieldDefn.GetSpatialRef() != null) {

                IProjection projection =

                    CRSFactory.getCRSFactory().get(ICRSFactory.FORMAT_WKT,

                        geomFieldDefn.GetSpatialRef().ExportToWkt());

                attributeDescriptor.setSRS(projection);

            }

        }

        if (editableFeatureType.getAttributeDescriptor(defaultGeometryField) != null) {

            editableFeatureType.setDefaultGeometryAttributeName(defaultGeometryField);

        } else {

            FeatureAttributeDescriptor[] attributeDescriptors =

                editableFeatureType.getAttributeDescriptors();

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

                if (attributeDescriptors[i].getDataType().getType() != DataTypes.GEOMETRY) {

                    continue;

                }

                if (attributeDescriptors[i].getGeomType().getType() == convertToGeomType(featureDefn

                    .GetGeomType())) {

                    editableFeatureType.setDefaultGeometryAttributeName(attributeDescriptors[i]

                        .getName());

                    LOG.warn(

                        "Default geometry field {} has not been found. Setting \"{}\" as default geometry field",

                        new Object[] { defaultGeometryField, attributeDescriptors[i].getName() });

                    break;

                }

            }

            if (editableFeatureType.getDefaultGeometryAttributeName() == null) {

                LOG.warn("The default geometry field can not be set");

            }

        }

        return editableFeatureType.getNotEditableCopy();

    }

    /**

     * Converts {@link FeatureAttributeDescriptor} of {@link FeatureType} to

     * {@link FieldDefn}

     *

     * @param featureType

     *            Fields to be converted

     * @return FieldDefn list OGR fields

     */

    public List<FieldDefn> convertFields(FeatureType featureType) {

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

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

            FeatureAttributeDescriptor attributeDescriptor = featureType.getAttributeDescriptor(i);

            if (attributeDescriptor.getType() != DataTypes.GEOMETRY) {

                fields.add(convertField(attributeDescriptor));

            }

        }

        return fields;

    }

    /**

     * Converts {@link FeatureAttributeDescriptor} to {@link FieldDefn}

     *

     * @param attDescriptor

     * @return FieldDefn

     */

    public FieldDefn convertField(FeatureAttributeDescriptor attDescriptor) {

        if (attDescriptor != null) {

            FieldDefn fieldDefn =

                new FieldDefn(attDescriptor.getName(), this.convertToOGRType(attDescriptor

                    .getType()));

            fieldDefn.SetPrecision(attDescriptor.getPrecision());

            return fieldDefn;

        }

        return null;

    }

    /**

     * Converts geometry {@link FeatureAttributeDescriptor} of

     * {@link FeatureType} to {@link GeomFieldDefn}

     *

     * @param featureType

     *            Geometry fields to be converted

     * @param convertDefaultGeometryColumn

     *            True if default geometry will be converted, otherwise default

     *            geometry field won't be converted.

     * @return GeomFieldDefn list OGR Geometry fields

     */

    public List<GeomFieldDefn> convertGeometryFields(FeatureType featureType,

        boolean convertDefaultGeometryColumn) {

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

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

            FeatureAttributeDescriptor attributeDescriptor = featureType.getAttributeDescriptor(i);

            if (attributeDescriptor.getType() == DataTypes.GEOMETRY) {

                // Check if default geometry column must be converted too

                if (i != featureType.getDefaultGeometryAttributeIndex()

                    || (i == featureType.getDefaultGeometryAttributeIndex() && convertDefaultGeometryColumn)) {

                    geometryFields.add(convertGeomField(attributeDescriptor));

                }

            }

        }

        return geometryFields;

    }

    /**

     * Converts {@link FeatureAttributeDescriptor} to {@link GeomFieldDefn}

     *

     * @param attDescriptor

     *            Attribute to be converted

     * @return GeomFieldDefn OGR Geometry field

     */

    public GeomFieldDefn convertGeomField(FeatureAttributeDescriptor attDescriptor) {

        String name = attDescriptor.getName();

        if (attDescriptor.getName().equals(DEFAULT_GEOMETRY_COLUMN_NAME)) {

            name = "";

        }

        GeomFieldDefn geomFieldDefn =

            new GeomFieldDefn(name,

                this.convertToOGRGeomType(attDescriptor.getGeomType().getType()));

        if (attDescriptor.getSRS() != null) {

            SpatialReference srs =

                new SpatialReference(attDescriptor.getSRS().export(ICRSFactory.FORMAT_WKT));

            geomFieldDefn.SetSpatialRef(srs);

        }

        return geomFieldDefn;

    }

    /**

     * Converts {@link Feature} to {@link FeatureProvider}. If

     * {@link FeatureProvider} is null, it will be instantiated. This method

     * only takes into account the fields of received {@link FeatureType}.

     *

     * @param featureProvider

     *

     * @param featureType

     *            Type of feature provider

     * @param ogrFeature

     *            OGR Feature to be converted

     * @return FeatureProvider

     *         FeatureProvder with OGR Feature values

     */

    public FeatureProvider convert(FeatureProvider featureProvider, FeatureType featureType,

        Feature ogrFeature) {

        int fid = ogrFeature.GetFID();

        if (featureProvider == null) {

            featureProvider = new DefaultFeatureProvider(featureType, fid);

        } else {

            featureProvider.setOID(fid);

        }

        FeatureDefn defnRef = ogrFeature.GetDefnRef();

        FeatureAttributeDescriptor[] attributeDescriptors = featureType.getAttributeDescriptors();

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

            if (attributeDescriptors[i].getDataType().getType() == DataTypes.GEOMETRY) {

                String name = attributeDescriptors[i].getName();

                org.gdal.ogr.Geometry ogrGeometry = null;

                int fieldIndex = -1;

                if (name.equals(DEFAULT_GEOMETRY_COLUMN_NAME)) {

                    // If geometry column name equals default column name,

                    // change it to empty string.

                    fieldIndex = defnRef.GetGeomFieldIndex("");

                } else {

                    fieldIndex = defnRef.GetGeomFieldIndex(name);

                }

                ogrGeometry = ogrFeature.GetGeomFieldRef(fieldIndex);

                if (ogrGeometry != null) {

                    Geometry geometry = null;

                    try {

                        geometry =

                            GeometryLocator.getGeometryManager().createFrom(

                                ogrGeometry.ExportToWkb());

                    } catch (BaseException e) {

                        LOG.warn(

                            String

                                .format(

                                    "Can not create geometry from %1s. Setting null value to geometry field",

                                    ogrGeometry.ExportToWkt()), e);

                        geometry = null;

                    }

                    if (attributeDescriptors[i].getName().equals(

                        featureType.getDefaultGeometryAttributeName())) {

                        featureProvider.setDefaultGeometry(geometry);

                    }

                    featureProvider.set(name, geometry);

                }

            } else {

                String name = attributeDescriptors[i].getName();

                int fieldIndex = defnRef.GetFieldIndex(name);

                FieldDefn fieldDefn = defnRef.GetFieldDefn(fieldIndex);

                int dataType = convertToDataType(fieldDefn.GetFieldType());

                Object value = null;

                if (dataType == DataTypes.INT) {

                    value = ogrFeature.GetFieldAsInteger(i);

                } else if (dataType == DataTypes.DOUBLE) {

                    value = ogrFeature.GetFieldAsDouble(i);

                } else {

                    value = ogrFeature.GetFieldAsString(i);

                }

                featureProvider.set(fieldDefn.GetName(), value);

            }

        }

        return featureProvider;

    }

    /**

     * Converts {@link FeatureProvider} to {@link Feature}.

     *

     * @param featureProvider

     *            Feature provider to be converted

     * @return Feature OGR Feature with feature provider values.

     * @throws GeometryOperationNotSupportedException

     *             If operation used to convert geometries is not supported

     * @throws GeometryOperationException

     *             If there are some problems converting geometries

     */

    public Feature convert(FeatureProvider featureProvider)

        throws GeometryOperationNotSupportedException, GeometryOperationException {

        if (featureProvider == null) {

            return null;

        }

        FeatureType featureType = featureProvider.getType();

        FeatureDefn featureDefn = new FeatureDefn();

        List<FieldDefn> fields = this.convertFields(featureType);

        for (FieldDefn fieldDefn : fields) {

            featureDefn.AddFieldDefn(fieldDefn);

        }

        List<GeomFieldDefn> geometryFields = this.convertGeometryFields(featureType, true);

        for (GeomFieldDefn geomFieldDefn : geometryFields) {

            featureDefn.AddGeomFieldDefn(geomFieldDefn);

        }

        Feature feature = new Feature(featureDefn);

        Integer oid = null;

        if (featureProvider.getOID() instanceof Integer) {

            oid = (Integer) featureProvider.getOID();

        } else if (featureProvider.getOID() instanceof Long) {

            oid = ((Long) featureProvider.getOID()).intValue();

        }

        feature.SetFID(oid);

        FeatureAttributeDescriptor[] attributeDescriptors = featureType.getAttributeDescriptors();

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

            Integer fieldIndex = null;

            if (attributeDescriptors[i].getType() == DataTypes.GEOMETRY

                && attributeDescriptors[i].getName().equals(DEFAULT_GEOMETRY_COLUMN_NAME)) {

                fieldIndex = featureDefn.GetGeomFieldIndex("");

            } else if (attributeDescriptors[i].getType() == DataTypes.GEOMETRY) {

                fieldIndex = featureDefn.GetGeomFieldIndex(attributeDescriptors[i].getName());

            } else {

                fieldIndex = featureDefn.GetFieldIndex(attributeDescriptors[i].getName());

            }

            Object value = featureProvider.get(i);

            if (value == null) {

                continue;

            }

            if (attributeDescriptors[i].getType() == DataTypes.STRING) {

                feature.SetField(fieldIndex, (String) value);

            } else if (attributeDescriptors[i].getType() == DataTypes.DOUBLE) {

                feature.SetField(fieldIndex, (Double) value);

            } else if (attributeDescriptors[i].getType() == DataTypes.BOOLEAN) {

                feature.SetField(fieldIndex, ((Boolean) value).toString());

            } else if (attributeDescriptors[i].getType() == DataTypes.DATE) {

                Date date = (Date) value;

                Calendar calendar = Calendar.getInstance();

                calendar.setTime(date);

                feature.SetField(i, calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH),

                    calendar.get(Calendar.DAY_OF_WEEK), calendar.get(Calendar.HOUR),

                    calendar.get(Calendar.MINUTE), calendar.get(Calendar.SECOND), 0);

            } else if (attributeDescriptors[i].getType() == DataTypes.GEOMETRY) {

                org.gvsig.fmap.geom.Geometry geometry = (Geometry) value;

                if (geometry != null) {

                    org.gdal.ogr.Geometry ogrGeometry = null;

                    if (attributeDescriptors[i].getSRS() != null) {

                        IProjection projection = attributeDescriptors[i].getSRS();

                        SpatialReference srs =

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

                        ogrGeometry = ogr.CreateGeometryFromWkt(geometry.convertToWKT(), srs);

                        feature.SetGeomField(i, ogrGeometry);

                    } else {

                        ogrGeometry = ogr.CreateGeometryFromWkt(geometry.convertToWKT());

                        feature.SetGeomField(fieldIndex, ogrGeometry);

                    }

                }

            }

        }

        return feature;

    }

    /**

     * Convert gvSIG geometry type to OGR geometry type. See

     * {@link ogrConstants}.

     *

     * @param type

     *            A type of {@link TYPES}

     * @return int Equivalent type of {@link ogrConstants}

     */

    public int convertToOGRGeomType(int type) {

        switch (type) {

        case TYPES.POINT:

            return ogrConstants.wkbPoint;

        case TYPES.CURVE:

        case TYPES.LINE:

        case TYPES.CIRCLE:

        case TYPES.ARC:

        case TYPES.ELLIPSE:

        case TYPES.SPLINE:

        case TYPES.ELLIPTICARC:

        case TYPES.CIRCUMFERENCE:

        case TYPES.PERIELLIPSE:

            return ogrConstants.wkbLineString;

        case TYPES.SURFACE:

        case TYPES.POLYGON:

        case TYPES.FILLEDSPLINE:

            return ogrConstants.wkbPolygon;

        case TYPES.AGGREGATE:

            return ogrConstants.wkbGeometryCollection;

        case TYPES.MULTIPOINT:

            return ogrConstants.wkbMultiPoint;

        case TYPES.MULTICURVE:

        case TYPES.MULTILINE:

            return ogrConstants.wkbMultiLineString;

        case TYPES.MULTISURFACE:

        case TYPES.MULTIPOLYGON:

            return ogrConstants.wkbMultiPolygon;

        case TYPES.NULL:

            return ogrConstants.wkbNone;

        case TYPES.GEOMETRY:

        case TYPES.MULTISOLID:

        case TYPES.SOLID:

        case TYPES.COMPLEX:

        default:

            return ogrConstants.wkbUnknown;

        }

    }

    /**

     * Convert OGR geometry type to gvSIG geometry type. See {@link TYPES}.

     *

     * @param type

     *            A type of {@link ogrConstants}

     * @return int Equivalent type of {@link TYPES}

     */

    public int convertToGeomType(int type) {

        switch (type) {

        case ogrConstants.wkbPoint:

            return TYPES.POINT;

        case ogrConstants.wkbLineString:

            return TYPES.CURVE;

        case ogrConstants.wkbPolygon:

            return TYPES.SURFACE;

        case ogrConstants.wkbGeometryCollection:

            return TYPES.AGGREGATE;

        case ogrConstants.wkbMultiPoint:

            return TYPES.MULTIPOINT;

        case ogrConstants.wkbMultiLineString:

            return TYPES.MULTILINE;

        case ogrConstants.wkbMultiPolygon:

            return TYPES.MULTISURFACE;

        case ogrConstants.wkbNone:

            return TYPES.NULL;

        case ogrConstants.wkbUnknown:

        default:

            return TYPES.GEOMETRY;

        }

    }

    /**

     * Convert gvSIG type to OGR type. See {@link ogrConstants}.

     *

     * @param type

     *            A type of {@link DataTypes}

     * @return int Equivalent type of {@link ogrConstants}

     */

    public int convertToOGRType(int type) {

        switch (type) {

        case DataTypes.DATE:

            return ogrConstants.OFTDate;

        case DataTypes.DOUBLE:

        case DataTypes.FLOAT:

            return ogrConstants.OFTReal;

        case DataTypes.STRING:

            return ogrConstants.OFTString;

        case DataTypes.CHAR:

            return ogrConstants.OFTString;

        case DataTypes.INT:

            return ogrConstants.OFTInteger;

        case DataTypes.LONG: // There is not LONG type support

        default:

            return ogrConstants.OFTString;

        }

    }

    /**

     * Convert OGR type to gvSIG type. See {@link DataTypes}.

     *

     * @param type

     *            A type of {@link ogrConstants}

     * @return int Equivalent type of {@link DataTypes}

     */

    public int convertToDataType(int type) {

        switch (type) {

        case ogrConstants.OFTDate:

            return DataTypes.DATE;

        case ogrConstants.OFTReal:

            return DataTypes.DOUBLE;

        case ogrConstants.OFTInteger:

            return DataTypes.INT;

        case ogrConstants.OFTTime:

            return DataTypes.TIME;

        case ogrConstants.OFTString:

        default:

            return DataTypes.STRING;

        }

    }

    /**

     * Convert OGR Feature to another OGR Feature. This method take into account

     * only {@link FeatureDefn} fields to create new feature. This method is

     * useful when OGR {@link Layer} is copied to new {@link DataSource}.

     *

     * @param layerDefn

     *            Definition of new feature

     * @param feature

     *            OGR feature to be converted

     * @return Fixed feature

     */

    public org.gdal.ogr.Feature convert(FeatureDefn layerDefn, org.gdal.ogr.Feature feature) {

        Feature newFeature = new Feature(layerDefn);

        for (int i = 0; i < feature.GetDefnRef().GetFieldCount(); i++) {

            FieldDefn fieldDefn = feature.GetDefnRef().GetFieldDefn(i);

            int fieldIndex = newFeature.GetDefnRef().GetFieldIndex(fieldDefn.GetName());

            if (fieldIndex != -1) {

                int fieldType = feature.GetDefnRef().GetFieldDefn(i).GetFieldType();

                switch (fieldType) {

                case ogrConstants.OFTDate:

                    int[] year = new int[1];

                    int[] month = new int[1];

                    int[] day = new int[1];

                    int[] hour = new int[1];

                    int[] minute = new int[1];

                    int[] second = new int[1];

                    int[] flags = new int[1];

                    feature.GetFieldAsDateTime(i, year, month, day, hour, minute, second, flags);

                    newFeature.SetField(i, year[0], month[0], day[0], hour[0], minute[0],

                        second[0], flags[0]);

                    break;

                case ogrConstants.OFTReal:

                    newFeature.SetField(i, feature.GetFieldAsDouble(i));

                    break;

                case ogrConstants.OFTInteger:

                    newFeature.SetField(i, feature.GetFieldAsInteger(i));

                    break;

                case ogrConstants.OFTString:

                default:

                    newFeature.SetField(i, feature.GetFieldAsString(i));

                    break;

                }

            }

        }

        for (int i = 0; i < feature.GetDefnRef().GetGeomFieldCount(); i++) {

            GeomFieldDefn geomFieldDefn = feature.GetDefnRef().GetGeomFieldDefn(i);

            int fieldIndex = newFeature.GetDefnRef().GetGeomFieldIndex(geomFieldDefn.GetName());

            if (fieldIndex != -1) {

                if (geomFieldDefn.GetFieldType() == newFeature.GetGeomFieldDefnRef(fieldIndex)

                    .GetFieldType()) {

                    org.gdal.ogr.Geometry geometry =

                        feature.GetGeomFieldRef(geomFieldDefn.GetName());

                    newFeature.SetGeomField(fieldIndex, geometry);

                } else {

                    LOG.warn(

                        "Ignoring geometry field. Can not fix {}. Geometry type is not equals",

                        geomFieldDefn.GetName());

                }

            }

        }

        return newFeature;

    }

}