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

import java.awt.geom.AffineTransform;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.Geometry.DIMENSIONS;

import org.gvsig.fmap.geom.GeometryUtils;

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

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

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

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.i18n.I18nManager;

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

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

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

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

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

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

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

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

/**

 * @author fdiaz

 *

 */

public class AlignEdgesEditingProvider extends AbstractEditingProvider implements EditingProvider {

    private static final String ALIGN_MODE = "_align_mode";

    private static final String ALIGN_UP = "_up";

    private static final String ALIGN_DOWN = "_down";

    private static final String ALIGN_LEFT = "_left";

    private static final String ALIGN_RIGHT = "_right";

    private static final String ALIGN_HORIZONTAL_CENTER = "_horizontal_centering";

    private static final String ALIGN_VERTICAL_CENTER = "_vertical_centering";

    private static final String ALIGN_BOTH_CENTER = "_both_centering";

    private static final String SHORT_ALIGN_UP = "_short_up";

    private static final String SHORT_ALIGN_DOWN = "_short_down";

    private static final String SHORT_ALIGN_LEFT = "_short_left";

    private static final String SHORT_ALIGN_RIGHT = "_short_right";

    private static final String SHORT_ALIGN_HORIZONTAL_CENTER = "_short_horizontal_centering";

    private static final String SHORT_ALIGN_VERTICAL_CENTER = "_short_vertical_centering";

    private static final String SHORT_ALIGN_BOTH_CENTER = "_short_both_centering";

    private static final String DO_COPY_QUESTION = "_do_copy_question";

    private static final String DELETE_ORIGINAL_GEOMETRIES = "_delete_original_geometries";

    private static final String DO_COPY = "_do_copy";

    private static final String YES = "_yes";

    private static final String NO = "_no";

    private static final String SHORT_YES = "_short_yes";

    private static final String SHORT_NO = "_short_no";

    //Variables est?ticas para guardarnos el align_mode y el do_copy

    private static String savedAlignMode;

    private static Boolean savedDoCopy;

    private final EditingServiceParameter geometryBaseParameter;

    private final EditingServiceParameter alignModeParameter;

    private final EditingServiceParameter doCopyParameter;

    private final EditingServiceParameter featureToAlignParameter;

    private final Map<EditingServiceParameter, Object> values;

    private final FeatureStore featureStore;

    private final MapContext mapContext;

    private List<Feature> selectedFeatures;

    /**

     * Default constructor.

     *

     * @param providerServices available services for this provider

     * @param parameters of this provider

     */

    public AlignEdgesEditingProvider(ProviderServices providerServices,

            DynObject parameters) {

        super(providerServices);

        I18nManager i18nManager = ToolsLocator.getI18nManager();

        this.featureStore

                = (FeatureStore) parameters

                        .getDynValue(EditingProviderFactory.FEATURE_STORE_FIELD);

        this.mapContext

                = (MapContext) parameters

                        .getDynValue(EditingProviderFactory.MAPCONTEXT_FIELD);

        this.geometryBaseParameter

                = new DefaultEditingServiceParameter("_geometry_base", "_geometry_base",

                        TYPE.POSITION);

        this.featureToAlignParameter

                = new DefaultEditingServiceParameter("_geometry_to_align", "_geometry_to_align",

                        TYPE.POSITION);

        DefaultEditingServiceParameterOptions alignModeOptions = new DefaultEditingServiceParameterOptions()

                .add(i18nManager.getTranslation(ALIGN_UP), ALIGN_UP, i18nManager.getTranslation(SHORT_ALIGN_UP))

                .add(i18nManager.getTranslation(ALIGN_DOWN), ALIGN_DOWN, i18nManager.getTranslation(SHORT_ALIGN_DOWN))

                .add(i18nManager.getTranslation(ALIGN_LEFT), ALIGN_LEFT, i18nManager.getTranslation(SHORT_ALIGN_LEFT))

                .add(i18nManager.getTranslation(ALIGN_RIGHT), ALIGN_RIGHT, i18nManager.getTranslation(SHORT_ALIGN_RIGHT))

                .add(i18nManager.getTranslation(ALIGN_HORIZONTAL_CENTER), ALIGN_HORIZONTAL_CENTER, i18nManager.getTranslation(SHORT_ALIGN_HORIZONTAL_CENTER))

                .add(i18nManager.getTranslation(ALIGN_VERTICAL_CENTER), ALIGN_VERTICAL_CENTER, i18nManager.getTranslation(SHORT_ALIGN_VERTICAL_CENTER))

                .add(i18nManager.getTranslation(ALIGN_BOTH_CENTER), ALIGN_BOTH_CENTER, i18nManager.getTranslation(SHORT_ALIGN_BOTH_CENTER))

                ;

        String alignModeConsoleMsg

                = ((EditingProviderServices) providerServices).makeConsoleMessage(

                        i18nManager.getTranslation(ALIGN_MODE), alignModeOptions);

        this.alignModeParameter

                = new DefaultEditingServiceParameter(

                        ALIGN_MODE,

                        alignModeConsoleMsg,

                        alignModeOptions,

                        i18nManager.getTranslation(SHORT_ALIGN_BOTH_CENTER),

                        true, 

                        TYPE.OPTION);

        DefaultEditingServiceParameterOptions doCopyOptions=  new DefaultEditingServiceParameterOptions()

                .add(DO_COPY, true, i18nManager.getTranslation(SHORT_YES))

                .add(DELETE_ORIGINAL_GEOMETRIES, false, i18nManager.getTranslation(SHORT_NO));

        String consoleMsg

                = ((EditingProviderServices) providerServices).makeConsoleMessage(

                        DO_COPY_QUESTION, doCopyOptions);

        this.doCopyParameter

                = new DefaultEditingServiceParameter(

                        DO_COPY,

                        consoleMsg, 

                        doCopyOptions, 

                        i18nManager.getTranslation(SHORT_YES), 

                        true, 

                        TYPE.OPTION).setDataType(DataTypes.BOOLEAN);

        this.values = new HashMap<>();

    }

    @Override

    public String getName() {

        return AlignEdgesEditingProviderFactory.PROVIDER_NAME;

    }

    @Override

    public EditingServiceParameter next() {

        if (values.get(geometryBaseParameter) == null) {

            return this.geometryBaseParameter;

        } else if (values.get(alignModeParameter) == null) {

            return this.alignModeParameter;

        } else if (values.get(doCopyParameter) == null) {

            return this.doCopyParameter;

        } else if (values.get(featureToAlignParameter) == null) {

            return this.featureToAlignParameter;

        }

        return null;

    }

    @Override

    public DrawingStatus getDrawingStatus(Point mousePosition)

            throws DrawServiceException {

        DefaultDrawingStatus geometries = new DefaultDrawingStatus();

        EditingProviderManager editingProviderManager

                = EditingProviderLocator.getProviderManager();

        ISymbol lineSymbolEditing = editingProviderManager.getSymbol("line-symbol-editing");

        ISymbol auxiliaryLineSymbolEditing = editingProviderManager.getSymbol("auxiliary-line-symbol-editing");

        ISymbol auxiliaryPointSymbolEditing = editingProviderManager.getSymbol("auxiliary-point-symbol-editing");

        ISymbol polygonSymbolEditing = editingProviderManager.getSymbol("polygon-symbol-editing");

        EditingProviderServices editingProviderServices

                = (EditingProviderServices) getProviderServices();

        try {

            int subtype = editingProviderServices.getSubType(featureStore);

            if (values != null) {

                Geometry geometryBaseValue = (Geometry) values.get(geometryBaseParameter);

                String alignModeValue = (String) values.get(alignModeParameter);

                Boolean doCopyValue = (Boolean) values.get(doCopyParameter);

                if (geometryBaseValue != null) {

                    if (geometryBaseValue.getGeometryType().isTypeOf(Geometry.TYPES.POINT) || 

                            geometryBaseValue.getGeometryType().isTypeOf(Geometry.TYPES.MULTIPOINT)) {

                        geometries.addStatus(geometryBaseValue, auxiliaryPointSymbolEditing, "");

                    } else if (geometryBaseValue.getGeometryType().isTypeOf(Geometry.TYPES.CURVE) ||

                            geometryBaseValue.getGeometryType().isTypeOf(Geometry.TYPES.MULTICURVE)) {

                        geometries.addStatus(geometryBaseValue, auxiliaryLineSymbolEditing, "");

                    } else {

                        geometries.addStatus(geometryBaseValue, polygonSymbolEditing, "");

                    }

                    if (alignModeValue != null && doCopyValue != null) {

                        Feature feature = getFeatureToAlign(mousePosition); //getFeatureToAlign(mousePosition);

                        if (feature != null) {

                            ISymbol previewSymbol = this.getPreviewSymbol(feature);

                            Geometry geom = feature.getDefaultGeometry(); //getGeometryToAlign(mousePosition); //getFeatureToAlign(mousePosition);

                            if (geom != null) {

                                if (geom.getGeometryType().isTypeOf(Geometry.TYPES.POINT)

                                        || geom.getGeometryType().isTypeOf(Geometry.TYPES.MULTIPOINT)) {

                                    geometries.addStatus(geom, auxiliaryPointSymbolEditing, "");

                                } else if (geom.getGeometryType().isTypeOf(Geometry.TYPES.CURVE)

                                        || geom.getGeometryType().isTypeOf(Geometry.TYPES.MULTICURVE)) {

                                    geometries.addStatus(geom, auxiliaryLineSymbolEditing, "");

                                } else if (geom.getGeometryType().isTypeOf(Geometry.TYPES.SURFACE)

                                        || geom.getGeometryType().isTypeOf(Geometry.TYPES.MULTISURFACE)) {

                                    geometries.addStatus(geom, polygonSymbolEditing, "");

                                }

                                geometries.addStatus(geom, previewSymbol, "");

                                Geometry alignedGeom = align(geometryBaseValue, geom, alignModeValue);

                                if (alignedGeom != null) {

                                    Point basePoint = getAlignPoint(geometryBaseValue, alignModeValue);

                                    Point geomPoint = getAlignPoint(alignedGeom, alignModeValue);

                                    Line alignLine = GeometryUtils.createLine(basePoint, geomPoint, subtype);

                                    geometries.addStatus(alignLine, auxiliaryLineSymbolEditing, "");

                                    if (alignedGeom.getGeometryType().isTypeOf(Geometry.TYPES.POINT)

                                            || alignedGeom.getGeometryType().isTypeOf(Geometry.TYPES.MULTIPOINT)) {

                                        geometries.addStatus(alignedGeom, auxiliaryPointSymbolEditing, "");

                                    } else if (alignedGeom.getGeometryType().isTypeOf(Geometry.TYPES.CURVE)

                                            || alignedGeom.getGeometryType().isTypeOf(Geometry.TYPES.MULTICURVE)) {

                                        geometries.addStatus(alignedGeom, lineSymbolEditing, "");

                                    } else if (alignedGeom.getGeometryType().isTypeOf(Geometry.TYPES.SURFACE)

                                            || alignedGeom.getGeometryType().isTypeOf(Geometry.TYPES.MULTISURFACE)) {

                                        geometries.addStatus(alignedGeom, polygonSymbolEditing, "");

                                    }

                                    geometries.addStatus(alignedGeom, previewSymbol, "");

                                }

                            }

                        }

                    }

                }

            }

        } catch (Exception e) {

            throw new DrawServiceException(e);

        }

        return geometries;

    }

    @Override

    public List<EditingServiceParameter> getParameters() {

        List<EditingServiceParameter> parameters

                = new ArrayList<>();

        parameters.add(geometryBaseParameter);

        parameters.add(alignModeParameter);

        parameters.add(doCopyParameter);

        parameters.add(featureToAlignParameter);

        return parameters;

    }

    @Override

    public boolean isEnabled(EditingServiceParameter parameter) {

        return true;

    }

    @Override

    public void setValue(EditingServiceParameter parameter, Object value) throws InvalidEntryException {

        validateAndInsertValue(parameter, value);

    }

    @Override

    public void setValue(Object value) throws InvalidEntryException {

        EditingServiceParameter param = next();

        validateAndInsertValue(param, value);

    }

    private void validateAndInsertValue(EditingServiceParameter param,

            Object value) throws InvalidEntryException {

        if (param == geometryBaseParameter) {

            if (value instanceof Point) {

                Point point = (Point) value;

                Geometry geom = getGeometryOfVisibleLayers(point);

                if (geom != null) {

                    values.put(param, geom);

                    return;

                }

            }

        } else if (param == featureToAlignParameter) {

            if (value instanceof Point) {

                Point point = (Point) value;

                Feature feat = getFeatureToAlign(point);

                if (feat != null) {

                    values.put(param, feat);

                    return;

                }

            }

        } else if (param == alignModeParameter) {

                savedAlignMode = (String) param.getOptions2().getValue(value, param.getDefaultValue());

                values.put(param, savedAlignMode);

                return;

        } else if (param == doCopyParameter) {

            savedDoCopy = (Boolean) param.getOptions2().getValue(value, param.getDefaultValue());

            values.put(param, savedDoCopy);

            return;

        }

        throw new InvalidEntryException(null);

    }

    private Geometry getGeometryOfVisibleLayers(Point point) {

        EditingProviderServices editingProviderServices = (EditingProviderServices) getProviderServices();

        Geometry geometry = editingProviderServices.getGeometryOfVisibleLayers(point, featureStore, mapContext);

        return geometry;

    }

    private Feature getFeatureToAlign(Point point) {

        EditingProviderServices editingProviderServices = (EditingProviderServices) getProviderServices();

        Feature feature = editingProviderServices.getFeature(point, featureStore, mapContext);

        return feature;

    }

    private Geometry getGeometryToAlign(Point point) {

        EditingProviderServices editingProviderServices = (EditingProviderServices) getProviderServices();

        return editingProviderServices.getGeometry(point, featureStore, mapContext);

    }

    @Override

    public Geometry finish() throws FinishServiceException {

        return null;

    }

    @Override

    public void finishAndStore() throws FinishServiceException {

        Geometry geometryBaseValue = (Geometry) values.get(geometryBaseParameter);

        Feature featureValue = (Feature) values.get(featureToAlignParameter);

        String alignModeValue = (String) values.get(alignModeParameter);

        Boolean doCopy = (Boolean) values.get(doCopyParameter);

        EditingProviderServices editingProviderServices

                = (EditingProviderServices) getProviderServices();

        try {

            Geometry geom;

            geom = align(geometryBaseValue, featureValue.getDefaultGeometry(), alignModeValue);

            if (doCopy) {

                // Se crea una feature nueva copiando los valores de

                // la feature original excepto aquellos que sean PK

                EditableFeature editableFeature

                        = editingProviderServices

                                .getFeatureCopyWithoutUniqueIndex(featureStore,

                                        featureValue);

                editableFeature.setDefaultGeometry(geom);

                editingProviderServices

                        .insertFeatureIntoFeatureStore(editableFeature,

                                featureStore);

            } else {

                // Se sustituye la geometr?a original por la

                // calculada

                EditableFeature editableFeature

                        = featureValue.getEditable();

                editableFeature.setDefaultGeometry(geom);

                ((EditingProviderServices) getProviderServices())

                        .updateFeatureInFeatureStore(editableFeature,

                                featureStore);

            }

        } catch (Exception e) {

            throw new FinishServiceException(e);

        }

    }

    private Geometry align(Geometry geometryBase, Geometry geometry, String alignMode) {

        if (geometryBase != null && geometry != null) {

            geometry = geometry.cloneGeometry();

            AffineTransform at = getAffineTransform(geometryBase, geometry, alignMode);

            geometry.transform(at);

        }

        return geometry;

    }

    private Point getAlignPoint(Geometry geometry, String alignMode) {

        Point point = null;

        if (geometry != null) {

            if (geometry instanceof Point) {

                point = (Point) geometry;

            } else {

                Envelope env = geometry.getEnvelope();

                switch (alignMode) {

                    case ALIGN_UP:

                        point = GeometryUtils.createPoint(env.getCenter(DIMENSIONS.X), env.getMaximum(DIMENSIONS.Y));

                        break;

                    case ALIGN_DOWN:

                        point = GeometryUtils.createPoint(env.getCenter(DIMENSIONS.X), env.getMinimum(DIMENSIONS.Y));

                        break;

                    case ALIGN_LEFT:

                        point = GeometryUtils.createPoint(env.getMinimum(DIMENSIONS.X), env.getCenter(DIMENSIONS.Y));

                        break;

                    case ALIGN_RIGHT:

                        point = GeometryUtils.createPoint(env.getMaximum(DIMENSIONS.X), env.getCenter(DIMENSIONS.Y));

                        break;

                    case ALIGN_HORIZONTAL_CENTER:

                        point = GeometryUtils.createPoint(env.getCenter(DIMENSIONS.X), env.getCenter(DIMENSIONS.Y));

                        break;

                    case ALIGN_VERTICAL_CENTER:

                        point = GeometryUtils.createPoint(env.getCenter(DIMENSIONS.X), env.getCenter(DIMENSIONS.Y));

                        break;

                    case ALIGN_BOTH_CENTER:

                        point = GeometryUtils.createPoint(env.getCenter(DIMENSIONS.X), env.getCenter(DIMENSIONS.Y));

                        break;

                }

            }

        }

        return point;

    }

    private AffineTransform getAffineTransform(Geometry geometryBase, Geometry geometry, String alignMode) {

        Point basePoint = getAlignPoint(geometryBase, alignMode);

        Point geomPoint = getAlignPoint(geometry, alignMode);

        AffineTransform at = null;

        switch (alignMode) {

            case ALIGN_UP:

                at = new AffineTransform(

                        1d, 0d,

                        0d, 1d,

                        0d, basePoint.getY() - geomPoint.getY());

                break;

            case ALIGN_DOWN:

                at = new AffineTransform(

                        1d, 0d,

                        0d, 1d,

                        0d, basePoint.getY() - geomPoint.getY());

                break;

            case ALIGN_LEFT:

                at = new AffineTransform(

                        1d, 0d,

                        0d, 1d,

                        basePoint.getX() - geomPoint.getX(), 0d);

                break;

            case ALIGN_RIGHT:

                at = new AffineTransform(

                        1d, 0d,

                        0d, 1d,

                        basePoint.getX() - geomPoint.getX(), 0d);

                break;

            case ALIGN_HORIZONTAL_CENTER:

                at = new AffineTransform(

                        1d, 0d,

                        0d, 1d,

                        0d, basePoint.getY() - geomPoint.getY());

                break;

            case ALIGN_VERTICAL_CENTER:

                at = new AffineTransform(

                        1d, 0d,

                        0d, 1d,

                        basePoint.getX() - geomPoint.getX(), 0d);

                break;

            case ALIGN_BOTH_CENTER:

                at = new AffineTransform(

                        1d, 0d,

                        0d, 1d,

                        basePoint.getX() - geomPoint.getX(), basePoint.getY() - geomPoint.getY());

                break;

        }

        return at;

    }

    @Override

    public void activate() {

        //Se limpia todo pero se recuperan los valores guardados de alignMode y doCopy

        this.values.clear();

        if(savedAlignMode != null){

            this.values.put(alignModeParameter, savedAlignMode);

        }

        if(savedDoCopy != null){

            this.values.put(doCopyParameter, savedDoCopy);

        }

    }

    @Override

    public void start() throws StartServiceException {

    }

    @Override

    public void stop() throws StopServiceException {

        //Se limpiar solo la geometr?a a alinear

        this.values.remove(featureToAlignParameter);

    }

    @Override

    public Object getValue(EditingServiceParameter parameter) {

        return values != null ? values.get(parameter) : null;

    }

    private Feature getCurrentFeature() {

        return (Feature) getValue(featureToAlignParameter);

    }

}