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.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.geom.Geometry;

import org.gvsig.geoprocess.lib.api.GeoProcessLocator;

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

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

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

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

import es.unex.sextante.exceptions.WrongParameterTypeException;

import es.unex.sextante.gui.algorithm.GeoAlgorithmParametersPanel;

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

        /**

         * For polygonal buffers, only compute exterior buffers

         * (is the default operation, it applies to any geometry type)

         */

        public static final byte BUFFER_OUTSIDE_POLY        = 0;

        /**

         * For polygonal buffers, only compute interior buffers

         */

        public static final byte BUFFER_INSIDE_POLY         = 1;

        /**

         * For polygonal buffers, compute interior and exterior buffers

         */

        public static final byte BUFFER_INSIDE_OUTSIDE_POLY = 2;

    public static final byte SOURCE_FIELDS              = 0;

    public static final byte FID_DIST_FIELDS            = 1;

    public static final byte FID_FROM_TO_FIELDS         = 2;

    protected byte           tableFields                = -1; 

    private int              inflArea                   = BUFFER_OUTSIDE_POLY;

    protected boolean        dissolve                   = false;

    protected int            rings                      = 0;

    protected boolean        selectedGeom               = false;

    protected FeatureStore   inputStore                 = null;

    protected FeatureStore   outputStore                = null;

    protected IVectorLayer   sextanteInputLayer         = null;

    protected boolean        round_border               = false; 

    public static String[] sOptions = {

            GeoProcessLocator.getGeoProcessManager().getTranslation("poly_out"), 

            GeoProcessLocator.getGeoProcessManager().getTranslation("poly_in"),

            GeoProcessLocator.getGeoProcessManager().getTranslation("poly_inandout") 

    };

    public void defineCharacteristics() {

        setName(getTranslation("Buffer"));

        setGroup(getTranslation("basic_vect_algorithms"));

        // setGeneratesUserDefinedRasterOutput(false);

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

    }

    protected void readParameters() throws WrongParameterTypeException, NullParameterValueException, WrongParameterIDException {

            sextanteInputLayer = m_Parameters.getParameterValueAsVectorLayer(LAYER);

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

            rings = m_Parameters.getParameterValueAsInt(RING_NUMBER);

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

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

    }

    public boolean processAlgorithm() throws GeoAlgorithmExecutionException {

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

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

            }

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

        String attributeName = m_Parameters.getParameterValueAsString(FIELD);

        inflArea = m_Parameters.getParameterValueAsInt(AREA);

        readParameters();

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

            && inflArea != BUFFER_OUTSIDE_POLY) {

            JOptionPane.showMessageDialog(null,

                getTranslation("Wrong_type_for_this_shapetype"), "Error",

                JOptionPane.WARNING_MESSAGE);

            inflArea = BUFFER_OUTSIDE_POLY;

        }

        if (sextanteInputLayer instanceof FlyrVectIVectorLayer)

            inputStore = ((FlyrVectIVectorLayer) sextanteInputLayer).getFeatureStore();

        else

            return false;

        try {

            // Object to compute the distance

            IDistance distance = null;

            if (distanceValue == 0) {

                //int featureAttributePosition = ((FlyrVectIVectorLayer) sextanteInputLayer).getFeatureIndexByFieldIndex(attributePosition);

                distance = new FieldDistance(attributeName);//featureAttributePosition);

            } else {

                distance = new ConstantDistance(distanceValue);

            }

            // Object to compute the buffer operation

            BufferOperation operation = null;

            switch (inflArea) {

            case BUFFER_OUTSIDE_POLY:

                operation = new OutBufferOperation(distance, inputStore, this, getTableFieldsStructure());

                break;

            case BUFFER_INSIDE_POLY:

                operation = new InBufferOperation(distance, inputStore, this, getTableFieldsStructure());

                break;

            case BUFFER_INSIDE_OUTSIDE_POLY:

                operation = new InOutBufferOperation(distance, inputStore, this, getTableFieldsStructure());

                break;

            }

            operation.setTypeOfCap(round_border ? BufferOperation.CAP_ROUND : BufferOperation.CAP_SQUARE);

            operation.setGeoProcess(this, 100);

                // Builds the output FeatureStore

            outputStore = buildOutPutStore(IVectorLayer.SHAPE_TYPE_POLYGON,

                                                getTranslation("Buffer"), RESULT);

                if(!dissolve) {

                        computesBufferAlgWithoutDissolve(operation);

                } else {

                        computesBufferAlgWithDissolve(operation);

                }

        } catch (DataException e) {

            Sextante.addErrorToLog(e);

            return false;

        }

                if(getTaskMonitor().isCanceled())

                        return false;

        return true;

    }

    private void computesOneRingBufferWithDissolve(

                    BufferOperation operation, 

                    FuseOperation fuseOp, 

                    String idFile,

                    int initialPosition,

                    int ringPosition) throws ValidateDataParametersException, DataException {

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

                FeatureStore outAuxFeatStore = buildTemporalStore(org.gvsig.fmap.geom.Geometry.TYPES.SURFACE, file, 

                                inputStore.getDefaultFeatureType().getDefaultSRS());

                operation.getDistance().setNumberOfRings(ringPosition + 1);

                operation.setNumberOfRadialBuffers(1);

                operation.setTaskStatus(getStatus());

                m_Task.setProgressText(getTranslation("calc_buffer") + " [Ring:" + (rings - ringPosition) + "]");

                operation.computesGeometryOperation(inputStore, outAuxFeatStore,

                                attrNames, selectedGeom, false, true);

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

                m_Task.setProgressText(getTranslation("fuse_spatially") + " [Ring:" + (rings - ringPosition) + "]");

                fuseOp.computesGeometryOperation(outAuxFeatStore, outputStore, attrNames, ringPosition == initialPosition ? true : false);

                outAuxFeatStore.dispose();

    }

    protected void computesBufferAlgWithDissolve(BufferOperation operation) throws DataException {

            long fileTmpId = System.currentTimeMillis();

            FuseOperation fuseOp = new FuseOperation(this);

            if(inflArea == BUFFER_OUTSIDE_POLY || inflArea == BUFFER_INSIDE_OUTSIDE_POLY) {

                    try {

                            for (int i = rings; i >= 0 ; i--) {

                                    computesOneRingBufferWithDissolve(

                                                    operation, 

                                                    fuseOp, 

                                                    fileTmpId + i + "",

                                                    rings,

                                                    i);

                            }

                    } catch (ValidateDataParametersException e) {

                            Sextante.addErrorToLog(e);

                    }

            }

            if(inflArea == BUFFER_INSIDE_POLY) {

                    try {

                            for (int i = 0; i < rings + 1 ; i++) {

                                    computesOneRingBufferWithDissolve(

                                                    operation, 

                                                    fuseOp, 

                                                    fileTmpId + i + "",

                                                    0,

                                                    i);

                            }

                    } catch (ValidateDataParametersException e) {

                            Sextante.addErrorToLog(e);

                    }

            }

            fuseOp.end();

    }

    protected void computesBufferAlgWithoutDissolve(BufferOperation operation) throws DataException {

            operation.setNumberOfRadialBuffers(rings + 1);

            operation.setTaskStatus(getStatus());

            operation.computesGeometryOperation(inputStore, 

                            outputStore,

                            attrNames, 

                            selectedGeom, 

                            false, 

                            true);

    }

    /**

     * Gets the constant with the table structure 

     * @return

     */

    protected byte getTableFieldsStructure() {

            if(tableFields == -1) {

            if(!dissolve) {

                    tableFields = SOURCE_FIELDS;

                } else {

                if (inflArea == BUFFER_INSIDE_OUTSIDE_POLY) 

                        tableFields = FID_FROM_TO_FIELDS;

                else

                        tableFields = FID_DIST_FIELDS;

                }

            }

            return tableFields;

    }

    /**

     * Open a <code>DataStore</code>

     * @param file

     * @param proj

     * @return

     * @throws InitializeException

     * @throws ProviderNotRegisteredException

     * @throws ValidateDataParametersException

     */

    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

     * @throws DataException 

     */

    protected FeatureStore buildOutPutStore(int shapeType, 

                    String sextanteLayerName, 

                    String sextanteLayerLabel) throws DataException {

            FeatureType featureType = inputStore.getDefaultFeatureType();

            if(getTableFieldsStructure() == SOURCE_FIELDS) {

                    return super.buildOutPutStore(featureType, shapeType,sextanteLayerName, sextanteLayerLabel);

            } 

            Class<?>[] types = null;

            if (getTableFieldsStructure() == FID_FROM_TO_FIELDS) {

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

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

            } 

            if (getTableFieldsStructure() == FID_DIST_FIELDS) {

                    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(int shapeType, 

                    String file, 

                    IProjection crs) throws DataException, ValidateDataParametersException {

            FeatureType featureType = inputStore.getDefaultFeatureType();

        int[] types = null;

        if(getTableFieldsStructure() == SOURCE_FIELDS) {

                FeatureAttributeDescriptor[] desc = featureType.getAttributeDescriptors();

                types = new int[desc.length - 1];

                attrNames = new String[desc.length - 1];

                int attrCount = 0;

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

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

                                types[attrCount] = desc[i].getType();

                                attrNames[attrCount] = desc[i].getName();

                                attrCount ++;

                        }

                        }

        }

        if (getTableFieldsStructure() == FID_FROM_TO_FIELDS) {

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

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

        }

        if (getTableFieldsStructure() == FID_DIST_FIELDS) {

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

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

        }

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

    }

        @SuppressWarnings("deprecation")

        public FeatureStore create(String sFilename,

                        int[] types, String[] attrNames, 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;

        }

    @Override

    public Class<? extends GeoAlgorithmParametersPanel> getCustomParametersPanelClass() {

        return BufferParametersPanel.class;

    }

}