Application: gvSIG desktop » gvSIG tools: Vector editing

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2014 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.vectorediting.lib.prov.autopolygon;

import java.util.ArrayList;

import java.util.List;

import org.cresques.cts.IProjection;

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

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

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

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

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.aggregate.MultiSurface;

import org.gvsig.fmap.geom.primitive.Point;

import org.gvsig.fmap.geom.primitive.Surface;

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

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

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.evaluator.Evaluator;

import org.gvsig.tools.service.spi.ProviderServices;

import org.gvsig.vectorediting.lib.api.DrawingStatus;

import org.gvsig.vectorediting.lib.api.EditingServiceParameter;

import org.gvsig.vectorediting.lib.api.EditingServiceParameter.TYPE;

import org.gvsig.vectorediting.lib.api.exceptions.DrawServiceException;

import org.gvsig.vectorediting.lib.api.exceptions.FinishServiceException;

import org.gvsig.vectorediting.lib.api.exceptions.InvalidEntryException;

import org.gvsig.vectorediting.lib.api.exceptions.StartServiceException;

import org.gvsig.vectorediting.lib.api.exceptions.StopServiceException;

import org.gvsig.vectorediting.lib.spi.AbstractEditingProvider;

import org.gvsig.vectorediting.lib.spi.DefaultEditingServiceParameter;

import org.gvsig.vectorediting.lib.spi.EditingProvider;

import org.gvsig.vectorediting.lib.spi.EditingProviderFactory;

import org.gvsig.vectorediting.lib.spi.EditingProviderServices;

@SuppressWarnings("UseSpecificCatch")

public class AutopolygonEditingProvider extends AbstractEditingProvider

    implements EditingProvider {

    private final EditingServiceParameter geometryParameter;

    private final FeatureStore featureStore;

    private Geometry geometryValue;

    public AutopolygonEditingProvider(ProviderServices services,

        DynObject parameters) {

        super(services);

        this.featureStore =

            (FeatureStore) parameters

                .getDynValue(EditingProviderFactory.FEATURE_STORE_FIELD);

        this.geometryParameter =

            new DefaultEditingServiceParameter("Draw geometry",

                "draw_geometry_to_autopolygon", Geometry.TYPES.MULTISURFACE, TYPE.GEOMETRY);

    }

    public EditingServiceParameter next() {

        if (geometryValue == null) {

            return geometryParameter;

        }

        return null;

    }

    public DrawingStatus getDrawingStatus(Point mousePosition)

        throws DrawServiceException {

        return null;

    }

    public void stop() throws StopServiceException {

        geometryValue = null;

    }

    public List<EditingServiceParameter> getParameters() {

        List<EditingServiceParameter> list = new ArrayList<>();

        list.add(geometryParameter);

        return list;

    }

    public void setValue(Object value) throws InvalidEntryException {

        EditingServiceParameter param = next();

        validateAndInsertValue(param, value);

    }

    private void validateAndInsertValue(EditingServiceParameter param,

        Object value) throws InvalidEntryException {

        if (param == geometryParameter) {

            if (value instanceof Geometry ) {

                Geometry geometry = (Geometry)value;

                GeometryType geometryType = geometry.getGeometryType();

                if (geometryType.isTypeOf(Geometry.TYPES.MULTISURFACE) ||

                    geometryType.isTypeOf(Geometry.TYPES.SURFACE)) {

                    geometryValue = geometry;

                    return;

                }

            }

        }

        throw new InvalidEntryException(null);

    }

    public void finishAndStore() throws FinishServiceException {

        EditingProviderServices editingProviderServices =

            (EditingProviderServices) getProviderServices();

        Geometry geometry = finish();

        editingProviderServices.insertGeometryIntoFeatureStore(geometry,

            featureStore);

    }

    public Geometry finish() throws FinishServiceException {

        EditingProviderServices editingProviderServices =

            (EditingProviderServices) getProviderServices();

        Geometry geometry = geometryValue.cloneGeometry();

        FeatureQuery query;

        try {

            query = queryByGeometry(geometry);

            if (query != null) {

                FeatureSet features = featureStore.getFeatureSet(query);

                DisposableIterator featuresIterator = features.fastIterator();

                while (featuresIterator.hasNext()) {

                    Feature feature = (Feature) featuresIterator.next();

                    geometry =

                        geometry.difference(feature.getDefaultGeometry());

                }

                featuresIterator.dispose();

                features.dispose();

            }

            GeometryType storeGeomType =

                editingProviderServices.getGeomType(featureStore);

            if (storeGeomType.isTypeOf(MULTISURFACE)) {

                MultiSurface multisurface;

                multisurface =

                    GeometryLocator.getGeometryManager().createMultiSurface(

                        storeGeomType.getSubType());

                multisurface.addSurface((Surface)geometry);

                return multisurface;

            }

        } catch (Exception e) {

            throw new FinishServiceException(e);

        }

        return geometry;

    }

    public void start() throws StartServiceException, InvalidEntryException {

        geometryValue = null;

    }

    public String getName() {

        return AutopolygonEditingProviderFactory.PROVIDER_NAME;

    }

    private FeatureQuery queryByGeometry(Geometry geometry) throws DataException {

        FeatureQuery featureQuery = featureStore.createFeatureQuery();

        FeatureType featureType = featureStore.getDefaultFeatureType();

        String geomName = featureType.getDefaultGeometryAttributeName();

        featureQuery.setFeatureType(featureType);

        IProjection query_proj = featureType.getDefaultSRS();

        Evaluator iee = SpatialEvaluatorsFactory.getInstance().intersects(

            geometry, 

            query_proj, 

            featureStore

        );

        featureQuery.setFilter(iee);

        featureQuery.setAttributeNames(null);

        return featureQuery;

    }

}