Application: gvSIG desktop » gvSIG geoprocess

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2012 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.geoprocess.lib.sextante.dataObjects;

import java.awt.geom.Rectangle2D;

import java.io.File;

import java.sql.Types;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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

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

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

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

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

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.serverexplorer.filesystem.FilesystemServerExplorer;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorerParameters;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemStoreParameters;

import org.gvsig.fmap.geom.DataTypes;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

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

import org.gvsig.fmap.geom.operation.fromjts.FromJTS;

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

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

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

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.exceptions.LoadLayerException;

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataTypesManager;

import org.gvsig.tools.locator.LocatorException;

import com.vividsolutions.jts.geom.Geometry;

import es.unex.sextante.core.Sextante;

import es.unex.sextante.dataObjects.AbstractVectorLayer;

import es.unex.sextante.dataObjects.IFeatureIterator;

import es.unex.sextante.dataObjects.IVectorLayer;

import es.unex.sextante.outputs.FileOutputChannel;

import es.unex.sextante.outputs.IOutputChannel;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class FlyrVectIVectorLayer extends AbstractVectorLayer {

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

    private static final DataManager DATA_MANAGER = DALLocator.getDataManager();

    private final int PRECISION = 5;

    private FeatureStore featureStore = null;

    private IProjection m_Projection = null;

    private FeatureType featureType = null;

    private GeometryManager geometryManager = null;

    private FLyrVect m_Layer;

    private String m_sName;

    private IOutputChannel m_Channel;

    private String fileName = null;

    private List<String> names = new ArrayList<String>();

        private List<Class<?>> types = new ArrayList<Class<?>>();

    // private Object inputParameters = null;

    public FlyrVectIVectorLayer() {

        geometryManager = GeometryLocator.getGeometryManager();

    }

    public void create(String sName, Object inputParams, int iShapeType,

        Class[] types, String[] sFields, Object crs, int[] fieldSize) {

        create(sName, inputParams, iShapeType,

        types, sFields, crs, fieldSize, org.gvsig.fmap.geom.Geometry.SUBTYPES.UNKNOWN);

    }

    public void create(String sName, Object inputParams, int iShapeType,

        Class[] types, String[] sFields, Object crs, int[] fieldSize, int subtype) {

        try {

            // inputParameters = inputParams;

            m_sName = sName;

            m_Projection = (IProjection) crs;

            if (inputParams instanceof OutputParameters) {

                OutputParameters outputParam = (OutputParameters) inputParams;

                NewFeatureStoreParameters newParams =

                    outputParam.getDataParameters();

                DataServerExplorer dataServerExplorer =

                    outputParam.getExplorer();

                featureType = newParams.getDefaultFeatureType();

                loadFeatureType(sFields, types, iShapeType, crs,

                    (EditableFeatureType) featureType, fieldSize, subtype);

                newParams.setDynValue("CRS", m_Projection);

                DATA_MANAGER.newStore(dataServerExplorer.getProviderName(),

                    newParams.getDataStoreName(), newParams, true);

                featureStore =

                    (FeatureStore) DATA_MANAGER.openStore(

                        newParams.getDataStoreName(), newParams);

                initializeNamesAndTypes();

                featureStore.edit(FeatureStore.MODE_APPEND);

            }

            if (inputParams instanceof FilesystemStoreParameters) {

                // TODO: Terminar para todo tipo fuentes de datos. No se puede

                // hacer ahora pq falta poder obtener un FeatureType del

                // parameter.

                // Esto es as? pq el store registra parameters para cargar

                // ficheros y no para escribirlos.

                String path =

                    ((FilesystemStoreParameters) inputParams).getFile()

                        .getAbsolutePath();

                create(sName, path, iShapeType, types, sFields, crs, fieldSize);

            }

            if (inputParams instanceof String) {

                create(sName, (String) inputParams, iShapeType, types, sFields,

                    crs, fieldSize);

            }

        } catch (Exception e) {

            Sextante.addErrorToLog(e);

        }

    }

    public void create(final String sName, final String sFilename,

        final int iShapeType, final Class<?>[] types, final String[] sFields,

        final Object crs, final int[] fieldSize) {

        create(sName, sFilename, iShapeType, types, sFields, crs, fieldSize, org.gvsig.fmap.geom.Geometry.SUBTYPES.UNKNOWN);

    }

    public void create(final String sName, final String sFilename,

        final int iShapeType, final Class<?>[] types, final String[] sFields,

        final Object crs, final int[] fieldSize, int subtype) {

        try {

            // inputParameters = sFilename;

            m_sName = sName;

            m_Projection = (IProjection) crs;

            fileName = sFilename;

            final FilesystemServerExplorerParameters explorerParams =

                (FilesystemServerExplorerParameters) DATA_MANAGER

                    .createServerExplorerParameters(FilesystemServerExplorer.NAME);

            explorerParams.setRoot(new File(sFilename).getParent());

            final FilesystemServerExplorer explorer =

                (FilesystemServerExplorer) DATA_MANAGER.openServerExplorer(

                    FilesystemServerExplorer.NAME, explorerParams);

            File file = new File(sFilename);

            final NewFeatureStoreParameters newParams =

                (NewFeatureStoreParameters) explorer.getAddParameters(file);

            EditableFeatureType editableFeatureType =

                newParams.getDefaultFeatureType();

            featureType = editableFeatureType;

            loadFeatureType(sFields, types, iShapeType, crs,

                editableFeatureType, fieldSize, subtype);

            newParams.setDefaultFeatureType(featureType);

            newParams.setDynValue("crs", m_Projection);

            explorer.add(newParams.getDataStoreName(), newParams, true);

            DataStoreParameters params = DATA_MANAGER.createStoreParameters(newParams.getDataStoreName());

            params.setDynValue("shpfile", sFilename);

            params.setDynValue("crs", m_Projection);

            featureStore = (FeatureStore) DATA_MANAGER.openStore(params.getDataStoreName(), params);

            featureStore.edit(FeatureStore.MODE_APPEND);

            featureType = featureStore.getDefaultFeatureType();

            initializeNamesAndTypes();

        } catch (final Exception e) {

            Sextante.addErrorToLog(e);

        }

    }

    private void loadFeatureType(final String[] fields, final Class<?>[] types,

        final int shapeType, final Object crs,

        final EditableFeatureType featureType, final int[] fieldSize, final int subtype) {

        final int[] iTypes = getTypes(types);

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

            if (iTypes[i] == DataTypes.GEOMETRY) {

                    // No se hace nada porque el resultado de los geoprocesos deben dejar una ?nica columna de geometr?a

                    // que a?adimos al final

            } else {

                featureType.add(fields[i], iTypes[i])

                        .setAllowNull(true)

                        .setSize(fieldSize[i])

                    .setPrecision(PRECISION);

            }

        }

        FeatureAttributeDescriptor desc =

            featureType.getDefaultGeometryAttribute();

        if (desc == null) {

            addGeometryAttribute("GEOMETRY", shapeType, subtype, featureType);

            featureType.setDefaultGeometryAttributeName("GEOMETRY");

        }

    }

    private void addGeometryAttribute(final String fieldName,

        final int shapeType, final int subtype, final EditableFeatureType featureType) {

        try {

            GeometryType type;

            if (subtype == org.gvsig.fmap.geom.Geometry.SUBTYPES.UNKNOWN) {

                type =

                    geometryManager.getGeometryType(getgvSIGShapeType(shapeType),

                        org.gvsig.fmap.geom.Geometry.SUBTYPES.GEOM2D);

            } else {

                type =

                    geometryManager.getGeometryType(getgvSIGShapeType(shapeType),subtype);

            }

            featureType.add(fieldName, DataTypes.GEOMETRY)

                .setGeometryType(type);

        } catch (GeometryTypeNotSupportedException e) {

            throw new RuntimeException(

                "Error getting geometry type with type = "

                    + getgvSIGShapeType(shapeType) + ", subtype = "

                    + org.gvsig.fmap.geom.Geometry.SUBTYPES.GEOM2D, e);

        } catch (GeometryTypeNotValidException e) {

            throw new RuntimeException(

                "Error getting geometry type with type = "

                    + getgvSIGShapeType(shapeType) + ", subtype = "

                    + org.gvsig.fmap.geom.Geometry.SUBTYPES.GEOM2D, e);

        }

    }

    private int[] getTypes(Class<?>[] classes) {

        DataTypesManager typesManager = ToolsLocator.getDataTypesManager();

        int[] types = new int[classes.length];

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

            types[i] = typesManager.getDataType(classes[i]).getType();

        }

        return types;

    }

    public void create(final FLyrVect layer) {

        m_Layer = layer;

        try {

            featureStore = layer.getFeatureStore();

            featureType = featureStore.getDefaultFeatureType();

            initializeNamesAndTypes();

            m_Projection = layer.getProjection();

        } catch (final Exception e) {

            Sextante.addErrorToLog(e);

        }

    }

    public void open() {

        if (m_Layer == null) {

            try {

                    m_Layer = (FLyrVect) MapContextLocator.getMapContextManager().createLayer(

                        getFilename(), featureStore);

            } catch (final LoadLayerException e) {

                Sextante.addErrorToLog(e);

                throw new RuntimeException(e);

            }

        }

    }

    public void close() {

        if( this.m_Layer==null ) {           

            this.free();

        }

    }

    /**

     * Returns the length of field

     *

     * @param dataType

     * @return length of field

     */

    public int getDataTypeLength(final int dataType) {

        switch (dataType) {

        case Types.NUMERIC:

        case Types.DOUBLE:

        case Types.REAL:

        case Types.FLOAT:

        case Types.BIGINT:

        case Types.INTEGER:

        case Types.DECIMAL:

            return 20;

        case Types.CHAR:

        case Types.VARCHAR:

        case Types.LONGVARCHAR:

            return 254;

        case Types.DATE:

            return 8;

        case Types.BOOLEAN:

        case Types.BIT:

            return 1;

        }

        return 0;

    }

    @SuppressWarnings("unchecked")

    public void addFeature(final Geometry geom, final Object[] values) {

        try {

            org.gvsig.fmap.geom.Geometry iGeo = null;

            final GeometryOperationContext ctx = new GeometryOperationContext();

            ctx.setAttribute(FromJTS.PARAM, geom);

            try {

                iGeo =

                    (org.gvsig.fmap.geom.Geometry) geometryManager

                        .invokeOperation(FromJTS.NAME, ctx);

            } catch (final GeometryOperationNotSupportedException e) {

                Sextante.addErrorToLog(e);

                return;

            } catch (final GeometryOperationException e) {

                Sextante.addErrorToLog(e);

                return;

            }

            final EditableFeature ef = featureStore.createNewFeature();

            final Iterator<FeatureAttributeDescriptor> features =

                featureType.iterator();

            int i = 0;

            while (features.hasNext()) {

                final FeatureAttributeDescriptor featureAttributeDescriptor =

                    features.next();

                if (!featureAttributeDescriptor.getName().equals(

                    featureType.getDefaultGeometryAttributeName())) {

                               ef.set(featureAttributeDescriptor.getName(), values[i]);

                }

                i++;

            }

            ef.set(featureType.getDefaultGeometryAttributeIndex(), iGeo);

            featureStore.insert(ef);

        } catch (final Exception e) {

            e.printStackTrace();

        }

    }

    public IFeatureIterator iterator() {

        if (m_Layer != null) {

            return new DALIFeatureIterator(m_Layer, getFilters());

        } else {

            // cannot iterate layers being edited

            return new DALIFeatureIterator();

        }

    }

    public String getFieldName(final int i) {

        if (featureStore != null) {

            return ((FeatureAttributeDescriptor) featureType.get(i)).getName();

        }

        return null;

    }

    public Class<?> getFieldType(final int i) {

            return types.get(i);

    }

    public int getFieldCount() {

        if (featureStore != null) {

            return names.size();

        }

        return 0;

    }

    @Override

    public int getShapesCount() {

        if (featureStore != null) {

            try {

                    FeatureSelection featureSelection = featureStore.getFeatureSelection();

                    if (!featureSelection.isEmpty()) {

                            return (int)featureSelection.getSize();

                    } else {

                            return (int)featureStore.getFeatureSet().getSize();

                    }

            } catch (final DataException e) {

                Sextante.addErrorToLog(e);

                return 0;

            }

        }

        return 0;

    }

    public int getShapeType() {

        if (featureStore != null) {

            return getShapeTypeFromGvSIGShapeType(((FeatureAttributeDescriptor) featureType

                .get(featureType.getDefaultGeometryAttributeIndex()))

                .getGeomType().getType());

        }

        return 0;

    }

    private int getShapeTypeFromGvSIGShapeType(final int shapeType) {

        if( geometryManager.isSubtype(org.gvsig.fmap.geom.Geometry.TYPES.SURFACE, shapeType) ) {

            return IVectorLayer.SHAPE_TYPE_POLYGON;

        }

        if( geometryManager.isSubtype(org.gvsig.fmap.geom.Geometry.TYPES.MULTISURFACE, shapeType) ) {

            return IVectorLayer.SHAPE_TYPE_POLYGON;

        }

        if( geometryManager.isSubtype(org.gvsig.fmap.geom.Geometry.TYPES.CURVE, shapeType) ) {

            return IVectorLayer.SHAPE_TYPE_LINE;

        }

        if( geometryManager.isSubtype(org.gvsig.fmap.geom.Geometry.TYPES.MULTICURVE, shapeType) ) {

            return IVectorLayer.SHAPE_TYPE_LINE;

        }

        if( geometryManager.isSubtype(org.gvsig.fmap.geom.Geometry.TYPES.POINT, shapeType) ) {

            return IVectorLayer.SHAPE_TYPE_POINT;

        }

        if( geometryManager.isSubtype(org.gvsig.fmap.geom.Geometry.TYPES.MULTIPOINT, shapeType) ) {

            return IVectorLayer.SHAPE_TYPE_POINT;

        }

        try {

            throw new IllegalArgumentException();

        } catch(Exception ex) {

            logger.warn("Geometry type "+ shapeType + " not supported.", ex);

        }

        return IVectorLayer.SHAPE_TYPE_POLYGON;

    }

    private int getgvSIGShapeType(final int shapeType) {

        switch (shapeType) {

        case IVectorLayer.SHAPE_TYPE_POLYGON:

            return org.gvsig.fmap.geom.Geometry.TYPES.POLYGON;

        case IVectorLayer.SHAPE_TYPE_LINE:

            return org.gvsig.fmap.geom.Geometry.TYPES.LINE;

        case IVectorLayer.SHAPE_TYPE_POINT:

            return org.gvsig.fmap.geom.Geometry.TYPES.POINT;

        case IVectorLayer.SHAPE_TYPE_MULTIPOLYGON:

            return org.gvsig.fmap.geom.Geometry.TYPES.MULTIPOLYGON;

        case IVectorLayer.SHAPE_TYPE_MULTILINE:

            return org.gvsig.fmap.geom.Geometry.TYPES.MULTILINE;

        case IVectorLayer.SHAPE_TYPE_MULTIPOINT:

            return org.gvsig.fmap.geom.Geometry.TYPES.MULTIPOINT;

        default:

            return org.gvsig.fmap.geom.Geometry.TYPES.POLYGON;

        }

    }

    public String getName() {

        if (m_Layer != null) {

            return m_Layer.getName();

        } else {

            return m_sName;

        }

    }

    public void postProcess() {

        if (featureStore == null) {

            return;

        }

        try {

            if( featureStore.isEditing() || featureStore.isAppending() ) {

                featureStore.finishEditing();

            }

            String name = featureStore.getProviderName();

            DataStoreParameters params = featureStore.getParameters();

            featureStore.dispose();

            featureStore = (FeatureStore) DALLocator.getDataManager().openStore(name, params);

            featureType = featureStore.getDefaultFeatureType();

        } catch (final Exception e) {

            logger.warn("Can't execute postProcess on '"+this.getName()+"'.",e);

                }

    }

    public String getFilename() {

            if(fileName != null)

                    return fileName;

            else

                    return m_sName;

    }

    public Object getCRS() {

        return m_Projection;

    }

    public void setName(final String name) {

        m_sName = name;

    }

    @Override

    public Object getBaseDataObject() {

        return m_Layer;

    }

    public void free() {

        if( this.featureStore!=null ) {

            if( featureStore.isEditing() || featureStore.isAppending() ) {

                try {

                    featureStore.finishEditing();

                } catch (DataException ex) {

                    logger.warn("Can't free '"+this.getName()+"'.",ex);

                }

            }            

            featureStore.dispose();

            featureStore = null;

        }

        if( m_Layer!=null ) {

            m_Layer.dispose();

            m_Layer = null;

        }

    }

    public IOutputChannel getOutputChannel() {

        if (featureStore != null) {

            final DataStoreParameters dsp = featureStore.getParameters();

            if (dsp instanceof FilesystemStoreParameters) {

                String file =

                    ((FilesystemStoreParameters) dsp).getFile()

                        .getAbsolutePath();

                return new FileOutputChannel(file);

            } else {

                return null;

            }

        } else {

            return m_Channel;

        }

    }

    public boolean canBeEdited() {

        // we support only file-based, so we can overwrite

        return true;

    }

    public FeatureStore getFeatureStore() {

        return featureStore;

    }

    public Rectangle2D getFullExtent() {

            org.gvsig.fmap.geom.primitive.Envelope envelope;

                try {

                        envelope = featureStore.getEnvelope();

                        return new Rectangle2D.Double(envelope.getMinimum(0), envelope.getMinimum(1), envelope.getLength(0), envelope.getLength(1));

                } catch (DataException e) {

                        return null;

                }

    }

    public String[] getFieldNames() {

            return (String[]) names.toArray(new String[names.size()]);

    }

    public int getFieldIndexByName(final String sFieldName) {

            String[] names = getFieldNames();

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

                        if(names[i].equalsIgnoreCase(sFieldName)) {

                                return i;

                        }

                }

            return -1;

    }

    public Class<?>[] getFieldTypes() {

            return (Class<?>[]) types.toArray(new Class<?>[types.size()]);

    }

    private void initializeNamesAndTypes() {

            int defaultGeometryAttributeIndex = this.featureType.getDefaultGeometryAttributeIndex();

            for(int i = 0; i < this.featureType.size(); i++){

                    if(i!=defaultGeometryAttributeIndex){

                            FeatureAttributeDescriptor attributeDescriptor = this.featureType.getAttributeDescriptor(i);

                                names.add(attributeDescriptor.getName());

                            types.add(attributeDescriptor.getDataType().getDefaultClass());

                    }

            }

    }

    /* (non-Javadoc)

     * @see es.unex.sextante.dataObjects.IVectorLayer#getSubType()

     */

    @Override

    public int getSubType() throws ReadException {

        if(m_Layer!=null){

            return m_Layer.getGeometryType().getSubType();

        }

        return org.gvsig.fmap.geom.Geometry.SUBTYPES.UNKNOWN;

    }

}