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

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.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.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.exceptions.LoadLayerException;

import org.gvsig.fmap.mapcontext.layers.LayerFactory;

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;

public class FlyrVectIVectorLayer extends AbstractVectorLayer {

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

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

                newParams.setDynValue("CRS", m_Projection);

                DATA_MANAGER.newStore(dataServerExplorer.getProviderName(),

                    newParams.getDataStoreName(), newParams, true);

                featureStore =

                    (FeatureStore) DATA_MANAGER.openStore(

                        newParams.getDataStoreName(), newParams);

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

            }

            /*

             * NewFeatureStoreParameters param =

             * (NewFeatureStoreParameters)inputParams;

             * featureType = param.getDefaultFeatureType();

             * loadFeatureType(sFields, types, iShapeType, crs, featureType,

             * fieldSize);

             * 

             * param.setDefaultFeatureType(featureType);

             * 

             * DataManager manager = DALLocator.getDataManager();

             * featureStore = (FeatureStore) manager.createStore(param);

             * featureStore.edit(FeatureStore.MODE_APPEND);

             */

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

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

            final NewFeatureStoreParameters newParams =

                (NewFeatureStoreParameters) explorer.getAddParameters(new File(

                    sFilename));

            EditableFeatureType editableFeatureType =

                newParams.getDefaultFeatureType();

            featureType = editableFeatureType;

            loadFeatureType(sFields, types, iShapeType, crs,

                editableFeatureType, fieldSize);

            newParams.setDefaultFeatureType(featureType);

            newParams.setDynValue("crs", m_Projection);

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

            featureStore =

                (FeatureStore) DATA_MANAGER.openStore(

                    newParams.getDataStoreName(), newParams);

            featureStore.edit(FeatureStore.MODE_APPEND);

            featureType = featureStore.getDefaultFeatureType();

        } 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[] iTypes = getTypes(types);

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

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

                addGeometryAttribute(fields[i], shapeType, featureType);

                featureType.setDefaultGeometryAttributeName(fields[i]);

            } else {

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

                    .setPrecision(PRECISION);

            }

        }

        FeatureAttributeDescriptor desc =

            featureType.getDefaultGeometryAttribute();

        if (desc == null) {

            addGeometryAttribute("GEOMETRY", shapeType, featureType);

            featureType.setDefaultGeometryAttributeName("GEOMETRY");

        }

    }

    private void addGeometryAttribute(final String fieldName,

        final int shapeType, final EditableFeatureType featureType) {

        try {

            GeometryType type =

                geometryManager.getGeometryType(getgvSIGShapeType(shapeType),

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

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

            m_Projection = layer.getProjection();

        } catch (final Exception e) {

            Sextante.addErrorToLog(e);

        }

    }

    @SuppressWarnings("deprecation")

    public void open() {

        if (m_Layer == null) {

            try {

                m_Layer =

                    (FLyrVect) LayerFactory.getInstance().createLayer(

                        getFilename(), featureStore);

            } catch (final LoadLayerException e) {

                Sextante.addErrorToLog(e);

                throw new RuntimeException(e);

            }

        }

    }

    public void close() {

    }

    /**

     * 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 featureStore == null ? null : featureType

            .getAttributeDescriptor(i).getDataType().getDefaultClass();

    }

    public int getFieldCount() {

        if (featureStore != null) {

            return featureType.size();

        }

        return 0;

    }

    @Override

    public int getShapesCount() {

        if (featureStore != null) {

            try {

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

        switch (shapeType) {

        case org.gvsig.fmap.geom.Geometry.TYPES.SURFACE:

            return IVectorLayer.SHAPE_TYPE_POLYGON;

        case org.gvsig.fmap.geom.Geometry.TYPES.CURVE:

        case org.gvsig.fmap.geom.Geometry.TYPES.MULTICURVE:

            return IVectorLayer.SHAPE_TYPE_LINE;

        case org.gvsig.fmap.geom.Geometry.TYPES.POINT:

        case org.gvsig.fmap.geom.Geometry.TYPES.MULTIPOINT:

            return IVectorLayer.SHAPE_TYPE_POINT;

        default:

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

        case IVectorLayer.SHAPE_TYPE_LINE:

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

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

        case IVectorLayer.SHAPE_TYPE_MULTILINE:

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

        case IVectorLayer.SHAPE_TYPE_MULTIPOINT:

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

        default:

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

        }

    }

    public String getName() {

        if (m_Layer != null) {

            return m_Layer.getName();

        } else {

            return m_sName;

        }

    }

    public void postProcess() {

        if (featureStore == null) {

            return;

        }

        try {

            featureStore.finishEditing();

            String name = featureStore.getProviderName();

            DataStoreParameters params = featureStore.getParameters();

            featureStore.dispose();

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

            featureStore.edit(FeatureStore.MODE_APPEND);

            featureType = featureStore.getDefaultFeatureType();

        } catch (final DataException e) {

            // No puede finalizar la edici?n. Es posible que se haya cerrado

            // previamente.

        } catch (ValidateDataParametersException e) {

                        org.slf4j.LoggerFactory.getLogger(FlyrVectIVectorLayer.class).debug("Error opening store", e);

                } catch (LocatorException e) {

                        org.slf4j.LoggerFactory.getLogger(FlyrVectIVectorLayer.class).debug("Error opening store", 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() {

        m_Layer.dispose();

        featureStore.dispose();

        m_Layer = null;

        featureStore = 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;

                }

    }

}