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.algorithm.buffer;

import java.io.File;

import javax.swing.JOptionPane;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.DataTypes;

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

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

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

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

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.geoprocess.algorithm.fusespatially.FuseSpatiallyAlgorithm;

import org.gvsig.geoprocess.lib.sextante.AbstractSextanteGeoProcess;

import org.gvsig.geoprocess.lib.sextante.dataObjects.FlyrVectIVectorLayer;

import org.hsqldb.Types;

import es.unex.sextante.additionalInfo.AdditionalInfoNumericalValue;

import es.unex.sextante.core.Sextante;

import es.unex.sextante.dataObjects.IVectorLayer;

import es.unex.sextante.exceptions.GeoAlgorithmExecutionException;

import es.unex.sextante.exceptions.OptionalParentParameterException;

import es.unex.sextante.exceptions.RepeatedParameterNameException;

import es.unex.sextante.exceptions.UndefinedParentParameterNameException;

import es.unex.sextante.exceptions.UnsupportedOutputChannelException;

import es.unex.sextante.outputs.OutputVectorLayer;

/**

 * Geoprocess that computes a buffer area around each feature's geometry of the

 * input layer. <br>

 * All the points interior to this buffer area has to be at a distance inferior

 * to "buffer distance" to the original geometry. This buffer distance could be

 * constant, or it could be a function of the value of a feature attribute.<br>

 * 

 * @author <a href="mailto:nachobrodin@gmail.com">Nacho Brodin</a>

 * @author gvSIG Team

 */

public class BufferAlgorithm extends AbstractSextanteGeoProcess {

    public static final String RESULT = "RESULT";

    public static final String LAYER = "LAYER";

    public static final String SELECTED_GEOM = "SELECTED_GEOM";

    public static final String DISTANCE = "DISTANCE";

    public static final String FIELD = "FIELD";

    public static final String DISSOLVE = "DISSOLVE";

    public static final String ROUND_BORDER = "ROUND_BORDER";

    public static final String AREA = "AREA";

    public static final String RING_NUMBER = "RING_NUMBER";

    public void defineCharacteristics() {

        setName(getTranslation("Buffer"));

        setGroup(getTranslation("basic_vect_algorithms"));

        // setGeneratesUserDefinedRasterOutput(false);

        String[] sOptions = {

                        getTranslation("poly_out"), 

                        getTranslation("poly_in"),

                getTranslation("poly_inandout") 

                };

        try {

            m_Parameters.addInputVectorLayer(LAYER, getTranslation("Input_layer"), 

                    IVectorLayer.SHAPE_TYPE_WRONG, true);

            m_Parameters.addBoolean(SELECTED_GEOM, getTranslation("Selected_geometries"), false);

            m_Parameters.addNumericalValue(DISTANCE, getTranslation("area_distance"), 0,

                AdditionalInfoNumericalValue.NUMERICAL_VALUE_DOUBLE);

            m_Parameters.addTableField(FIELD, getTranslation("area_field"), "LAYER");

            m_Parameters.addBoolean(DISSOLVE, getTranslation("Dissolve_entities"), false);

            m_Parameters.addBoolean(ROUND_BORDER, getTranslation("Round_border"), true);

            m_Parameters.addSelection(AREA, getTranslation("Builds_influence_area"), sOptions);

            m_Parameters.addSelection(RING_NUMBER, getTranslation("Number_of_rings"),

                new String[] { "1", "2", "3" });

        } catch (RepeatedParameterNameException e) {

            Sextante.addErrorToLog(e);

        } catch (UndefinedParentParameterNameException e) {

            Sextante.addErrorToLog(e);

        } catch (OptionalParentParameterException e) {

            Sextante.addErrorToLog(e);

        }

        addOutputVectorLayer(RESULT, getTranslation("Buffer"),

            OutputVectorLayer.SHAPE_TYPE_UNDEFINED);

    }

    public boolean processAlgorithm() throws GeoAlgorithmExecutionException {

            if(existsOutPutFile(BufferAlgorithm.RESULT, 0)) {

                    throw new GeoAlgorithmExecutionException(getTranslation("file_exists"));

            }

        IVectorLayer layer = m_Parameters.getParameterValueAsVectorLayer(LAYER);

        boolean selectedGeom = m_Parameters.getParameter(SELECTED_GEOM).getParameterValueAsBoolean();

        double dist = m_Parameters.getParameter(DISTANCE).getParameterValueAsDouble();

        int attributePosition = m_Parameters.getParameterValueAsInt(FIELD);

        // boolean dissolve =

        // m_Parameters.getParameter(DISSOLVE).getParameterValueAsBoolean();

        boolean round_border = m_Parameters.getParameter(ROUND_BORDER).getParameterValueAsBoolean();

        int inflArea = m_Parameters.getParameterValueAsInt(AREA);

        int rings = m_Parameters.getParameterValueAsInt(RING_NUMBER);

        boolean dissolve = m_Parameters.getParameter(DISSOLVE).getParameterValueAsBoolean();

        if (layer.getShapeType() != IVectorLayer.SHAPE_TYPE_POLYGON

            && inflArea != 0) {

            JOptionPane.showMessageDialog(null,

                getTranslation("Wrong_type_for_this_shapetype"), "Error",

                JOptionPane.WARNING_MESSAGE);

            inflArea = 0;

        }

        FeatureStore storeLayer = null;

        if (layer instanceof FlyrVectIVectorLayer)

            storeLayer = ((FlyrVectIVectorLayer) layer).getFeatureStore();

        else

            return false;

        try {

            FeatureSet features = null;

            features = storeLayer.getFeatureSet();

            FeatureType featureType = features.getDefaultFeatureType();

            // Object to compute the distance

            IDistance distance = null;

            if (dist == 0)

                distance = new FieldDistance(attributePosition);

            else

                distance = new ConstantDistance();

            // Object to compute the buffer operation

            BufferOperation operation = null;

            switch (inflArea) {

            case 0:

                operation = new OutBufferOperation(distance, layer, dist, this);

                break;

            case 1:

                operation = new InBufferOperation(distance, layer, dist, this);

                break;

            case 2:

                operation = new InOutBufferOperation(distance, layer, dist, this);

                break;

            }

            operation.setTypeOfCap(round_border ? BufferOperation.CAP_ROUND

                : BufferOperation.CAP_SQUARE);

            operation.setNumberOfRadialBuffers(rings + 1);

            operation.setGeoProcess(this, 100);

                // Builds the output FeatureStore

                FeatureStore outFeatStore =

                        buildOutPutStore(featureType,

                                        org.gvsig.fmap.geom.Geometry.TYPES.SURFACE,

                                        getTranslation("Buffer"), RESULT, inflArea);

            if(dissolve && rings == 0) { //solo se disuelve si hay un anillo

                    FeatureStore outAuxFeatStore = null;

                    try {

                            String file = System.getProperty("java.io.tmpdir") + File.separator + System.currentTimeMillis() + ".shp";

                            outAuxFeatStore = buildTemporalStore(featureType,

                                            org.gvsig.fmap.geom.Geometry.TYPES.SURFACE, file, inflArea, 

                                            storeLayer.getDefaultFeatureType().getDefaultSRS());

                            operation.setTaskStatus(getStatus());

                            operation.computesGeometryOperation(storeLayer, outAuxFeatStore,

                                            attrNames, selectedGeom, true);

                            outAuxFeatStore = open(file, storeLayer.getDefaultFeatureType().getDefaultSRS());

                            FuseSpatiallyAlgorithm alg = new FuseSpatiallyAlgorithm();

                            alg.setTaskMonitor(m_Task);

                            alg.setParentProcess(this);

                            m_Task.setProgressText(getTranslation("fuse_spatially"));

                            alg.execute(outAuxFeatStore, outFeatStore, IVectorLayer.SHAPE_TYPE_POLYGON, 

                                            false, getStatus(), "FID", false);

                    } catch (ValidateDataParametersException e) {

                            Sextante.addErrorToLog(e);

                    }

            } else { 

                    // Computes the operation

                    operation.setTaskStatus(getStatus());

                    operation.computesGeometryOperation(storeLayer, outFeatStore,

                                    attrNames, selectedGeom, true);

            } 

        } catch (DataException e) {

            Sextante.addErrorToLog(e);

            return false;

        }

                if(getTaskMonitor().isCanceled())

                        return false;

        return true;

    }

    private FeatureStore open(String file, IProjection proj) throws InitializeException, ProviderNotRegisteredException, ValidateDataParametersException {

            DataManager manager = DALLocator.getDataManager();

            DataStoreParameters params = manager.createStoreParameters("Shape");

            params.setDynValue("shpfile", file);

            params.setDynValue("crs", proj);

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

            return featureStore;

    }

    /**

     * Builds the output FeatureStore

     * 

     * @param featureType

     * @return FeatureStore

     */

    protected FeatureStore buildOutPutStore(FeatureType featureType,

        int shapeType, String sextanteLayerName, String sextanteLayerLabel,

        int infArea) {

        Class<?>[] types = null;

        if (infArea == 2) {

            types = new Class[] { Integer.class, Double.class, Double.class };

            attrNames = new String[] { "FID", "FROM", "TO" };

        } else {

            types = new Class[] { Integer.class, Double.class };

            attrNames = new String[] { "FID", "DIST" };

        }

        try {

            IVectorLayer output =

                getNewVectorLayer(sextanteLayerLabel, sextanteLayerName,

                    shapeType, types, attrNames);

            return ((FlyrVectIVectorLayer) output).getFeatureStore();

        } catch (UnsupportedOutputChannelException e) {

            Sextante.addErrorToLog(e);

        } catch (GeoAlgorithmExecutionException e) {

            Sextante.addErrorToLog(e);

        }

        return null;

    }

    /**

     * Builds the output FeatureStore

     * 

     * @param featureType

     * @return FeatureStore

     * @throws DataException 

     * @throws ValidateDataParametersException 

     */

    protected FeatureStore buildTemporalStore(FeatureType featureType,

        int shapeType, String file,

        int infArea, IProjection crs) throws DataException, ValidateDataParametersException {

        int[] types = null;

        if (infArea == 2) {

            types = new int[] { Types.INTEGER, Types.DOUBLE, Types.DOUBLE };

            attrNames = new String[] { "FID", "FROM", "TO" };

        } else {

            types = new int[] { Types.INTEGER, Types.DOUBLE };

            attrNames = new String[] { "FID", "DIST" };

        }

        return create(file, types, attrNames, crs);

    }

        @SuppressWarnings("deprecation")

        public FeatureStore create(String sFilename,

                        int[] types, String[] sFields, IProjection crs) {

                try {

                        DataManager manager = DALLocator.getDataManager();

                        FilesystemServerExplorerParameters explorerParams =

                            (FilesystemServerExplorerParameters) manager.createServerExplorerParameters("FilesystemExplorer");

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

                        FilesystemServerExplorer explorer = (FilesystemServerExplorer) manager.createServerExplorer(explorerParams);

                        NewFeatureStoreParameters newParams = (NewFeatureStoreParameters) explorer.getAddParameters(new File(sFilename));

                        EditableFeatureType ft = newParams.getDefaultFeatureType();

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

                                ft.add(attrNames[i], types[i], 7);

                        }

                        ft.add("GEOMETRY", DataTypes.GEOMETRY).setGeometryType(

                                        Geometry.TYPES.SURFACE).setGeometrySubType(Geometry.SUBTYPES.GEOM2D);

                        newParams.setDefaultFeatureType(ft);

                        newParams.setDynValue("CRS", crs);

                        newParams.setDynValue("geometryType", Geometry.TYPES.SURFACE);

                        manager.newStore("FilesystemExplorer",

                newParams.getDataStoreName(), newParams, true);

                        FeatureStore featureStore = (FeatureStore) manager.openStore(newParams.getDataStoreName(), newParams);                        

                        featureStore.edit(FeatureStore.MODE_APPEND);

                        return featureStore;

                } catch (Exception e) {

                        Sextante.addErrorToLog(e);

                }

                return null;

        }

}