Application: gvSIG desktop » gvSIG geoprocess

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2017 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.dispersepoints;

import java.util.ArrayList;

import java.util.Iterator;

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

import es.unex.sextante.exceptions.UnsupportedOutputChannelException;

import es.unex.sextante.outputs.OutputVectorLayer;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataTypes;

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

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.SpatialIndex;

import org.gvsig.fmap.geom.SpatialIndexFactory;

import org.gvsig.geoprocess.algorithm.base.core.GeometryOperation;

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

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

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

/**

 * @author fdiaz

 *

 */

public class DispersePointsAlgorithm extends AbstractSextanteGeoProcess {

    public static final String LAYER = "LAYER";

    public static final String RESULT = "RESULT";

    public static final String SCATTER_RADIUS = "SCATTER_RADIUS";

    public static final String MATCH_DISTANCE = "MATCH_DISTANCE";

    public static final String SELECTGEOM_INPUT = "SELECTGEOM_INPUT";

    /**

     *

     */

    public DispersePointsAlgorithm() {

        // TODO Auto-generated constructor stub

    }

    public void defineCharacteristics() {

        setName(getTranslation("_disperse_points"));

        setGroup(getTranslation("basic_vect_algorithms"));

        // setGeneratesUserDefinedRasterOutput(false);

        try {

            m_Parameters.addInputVectorLayer(LAYER,

                    getTranslation("input_layer"), IVectorLayer.SHAPE_TYPE_POINT,

                    true);

            addOutputVectorLayer(RESULT, getTranslation("_disperse_points"),

                    OutputVectorLayer.SHAPE_TYPE_POINT);

            m_Parameters.addNumericalValue(MATCH_DISTANCE, getTranslation("_match_distance"), 0, AdditionalInfoNumericalValue.NUMERICAL_VALUE_DOUBLE);

            m_Parameters.addNumericalValue(SCATTER_RADIUS, getTranslation("_scatter_radius"), 0, AdditionalInfoNumericalValue.NUMERICAL_VALUE_DOUBLE);

            m_Parameters.addBoolean(SELECTGEOM_INPUT, getTranslation("Selected_geometries_input_layer"), false);

        } catch (RepeatedParameterNameException e) {

            Sextante.addErrorToLog(e);

        }

    }

    /* (non-Javadoc)

     * @see es.unex.sextante.core.GeoAlgorithm#processAlgorithm()

     */

    @Override

    public boolean processAlgorithm() throws GeoAlgorithmExecutionException {

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

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

        }

        IVectorLayer layer = m_Parameters.getParameterValueAsVectorLayer(LAYER); //Capa de entrada

        double scatterRadius = m_Parameters.getParameter(SCATTER_RADIUS).getParameterValueAsDouble();

        double matchDistance = m_Parameters.getParameter(MATCH_DISTANCE).getParameterValueAsDouble();

        boolean selectedGeomInput = m_Parameters.getParameter(SELECTGEOM_INPUT).getParameterValueAsBoolean();

        FlyrVectIVectorLayer inputLayer = null;

        if(layer instanceof FlyrVectIVectorLayer) {

            inputLayer = ((FlyrVectIVectorLayer)layer); //Capa de entrada

        } else {

            return false;

        }

        DataManager dataManager = DALLocator.getDataManager();

        FeatureStore inputFeatureStore = inputLayer.getFeatureStore();

        //Builds the output and computes the operation

        try {

            FeatureType featureTypeInputLayer = inputFeatureStore.getDefaultFeatureType(); //Capa de entrada

            GeometryOperation operation = null;

            FeatureStore outFeatStore = null;

                outFeatStore =

                buildOutPutStore(featureTypeInputLayer, inputLayer.getShapeType(), getTranslation("_disperse_points"),

                    RESULT);

                operation =

                    new DispersePointsOperation(createIndex(inputLayer.getFeatureStore()), scatterRadius, matchDistance, this);

            operation.setTaskStatus(getStatus());

            operation.computesGeometryOperation(inputFeatureStore,

                    outFeatStore,

                    attrNames,

                    selectedGeomInput,

                    false,

                    true);

        } catch (Exception e) {

            Sextante.addErrorToLog(e);

        }

        return true;

    }

    private SpatialIndex createIndex(FeatureStore store) throws BaseException {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        SpatialIndexFactory factory = geomManager.getSpatialIndexFactory(geomManager.SPATIALINDEX_DEFAULT_RTREE);

        DynObject parameters = factory.createParameters();

        SpatialIndex index = (SpatialIndex) factory.create(parameters, geomManager);

        final SpatialIndex wrappedIndex = store.wrapSpatialIndex(index);

        Visitor visitor = new Visitor() {

            @Override

            public void visit(Object obj) throws VisitCanceledException, BaseException {

                Feature f = (Feature) obj;

                Geometry g = f.getDefaultGeometry();

                FeatureReference ref = f.getReference();

                wrappedIndex.insert(g, ref);

            }

        };

        store.accept(visitor);

        return wrappedIndex;

    }

    /**

     * Builds the output FeatureStore

     * @param featureType

     * @return FeatureStore

     */

    protected FeatureStore buildOutPutStore(FeatureType featureType1,

                                            int shapeType,

                                            String sextanteLayerName,

                                            String sextanteLayerLabel) {

        ArrayList<Class> typesList = new ArrayList<Class>();

        ArrayList<String> attr = new ArrayList<String>();

        Iterator it = featureType1.iterator();

        while( it.hasNext() ) {

            FeatureAttributeDescriptor attribute = (FeatureAttributeDescriptor)it.next();

            if (attribute.getDataType().getType() != DataTypes.GEOMETRY) {

                attr.add(attribute.getName());

                typesList.add(attribute.getObjectClass());

            }

        }

        attrNames = new String[attr.size()];

        attr.toArray(attrNames);

        Class[] types = new Class[typesList.size()];

        typesList.toArray(types);

        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;

    }

}