Application: gvSIG desktop » gvSIG tools: Vector editing

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2015 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.editvertex;

import java.awt.Color;

import java.awt.geom.AffineTransform;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.List;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

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

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

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

import org.gvsig.fmap.geom.exception.CreateGeometryException;

import org.gvsig.fmap.geom.operation.GeometryOperationException;

import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;

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

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

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

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

import org.gvsig.fmap.mapcontext.MapContext;

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

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

import org.gvsig.symbology.SymbologyLocator;

import org.gvsig.symbology.SymbologyManager;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.text.ISimpleTextSymbol;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.exception.BaseException;

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.prov.editvertex.operation.EditVertexOperation;

import org.gvsig.vectorediting.lib.prov.editvertex.operation.EditVertexOperationUtils;

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.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 EditVertexEditingProvider extends AbstractEditingProvider implements

    EditingProvider {

    private static final Logger logger = LoggerFactory

        .getLogger(EditVertexEditingProvider.class);

    private final int TOLERANCE_PIXELS = 3;

    private EditingServiceParameter selectionParameter;

    private EditingServiceParameter vertexSelectionPointParameter;

    private EditingServiceParameter actionParameter;

    private FeatureSelection selection;

    private Point selectedVertex;

    private int selectedIndex;

    private Point pointToMove;

    private String action;

    private FeatureStore featureStore;

    private MapContext mapContext;

    /**

     * Default constructor.

     * @param services

     *            available services for this provider

     * @param parameters

     *            of this provider

     */

    public EditVertexEditingProvider(ProviderServices services,

        DynObject parameters) {

        super(services);

        selectedIndex = -1;

        this.featureStore =

            (FeatureStore) parameters

                .getDynValue(EditingProviderFactory.FEATURE_STORE_FIELD);

        this.mapContext =

            (MapContext) parameters

                .getDynValue(EditingProviderFactory.MAPCONTEXT_FIELD);

        this.selectionParameter =

            new DefaultEditingServiceParameter("selection", "uniqueselection",

                TYPE.SELECTION);

        this.vertexSelectionPointParameter =

            new DefaultEditingServiceParameter("selectvertex", "selectvertex",

                TYPE.POSITION,

                TYPE.VALUE);

        LinkedHashMap<String, String> options = new LinkedHashMap<String, String>();

        options.put("+", "insert_vertex");

        options.put("-", "remove_vertex");

        GeometryType geomType = null;

        try {

            geomType = featureStore.getDefaultFeatureType().getDefaultGeometryAttribute().getGeomType();

        } catch (DataException e) {

            String message =

                String.format("Error getting feature type of %1",

                    featureStore);

            logger.info(message, e);

        }

        if(geomType != null && (geomType.isSubTypeOf(Geometry.SUBTYPES.GEOM3D) || geomType.isSubTypeOf(Geometry.SUBTYPES.GEOM3DM))){

            this.actionParameter =

                new DefaultEditingServiceParameter(

                    "new_position_or_z_value",

                    ((EditingProviderServices) getProviderServices()).makeConsoleMessage("new_position_or_z_value", options),

                    options,

                    TYPE.POSITION,

                    TYPE.OPTION,

                    TYPE.VALUE);

        } else {

            this.actionParameter =

                new DefaultEditingServiceParameter("new_position",

                    ((EditingProviderServices) getProviderServices()).makeConsoleMessage("new_position", options),

                    options, TYPE.POSITION, TYPE.OPTION);

        }

    }

    public EditingServiceParameter next() {

        if (selection == null) {

            return selectionParameter;

        } else if (selectedVertex == null) {

            return vertexSelectionPointParameter;

        } else if (action == null && pointToMove == null) {

            return actionParameter;

        }

        return null;

    }

    public DrawingStatus getDrawingStatus(Point mousePosition)

        throws DrawServiceException {

        DefaultDrawingStatus drawingStatus = new DefaultDrawingStatus();

        EditingProviderManager editingProviderManager =

            EditingProviderLocator.getProviderManager();

        ISymbol selectedVertexSymbolEditing =

            editingProviderManager.getSymbol("selected-vertex-symbol-editing");

        ISymbol editedVertexSymbolEditing =

            editingProviderManager.getSymbol("edited-vertex-symbol-editing");

        Color colorToTextSymbol = Color.BLACK;

        if (selectedVertexSymbolEditing != null) {

            colorToTextSymbol = selectedVertexSymbolEditing

                .getColor();

        }

        double translationForTextSymbol =

            mapContext.getViewPort().toMapDistance(5);

        double tolerance =

            mapContext.getViewPort().toMapDistance(TOLERANCE_PIXELS);

        try {

            if (this.selection == null) {

                Geometry geometry = null;

                geometry = getNearestGeometry(mousePosition);

                if (geometry != null) {

                    List<Point> vertexesList = getVertexesList(geometry);

                    if (vertexesList != null) {

                        int i = 0;

                        for (Iterator<Point> iterator = vertexesList.iterator(); iterator

                            .hasNext();) {

                            Point point = (Point) iterator.next();

                            drawingStatus.addStatus(point,

                                selectedVertexSymbolEditing, "");

                            Point pointToText = (Point) point.cloneGeometry();

                            pointToText.transform(new AffineTransform(1, 0, 0,

                                1, translationForTextSymbol, 0));

                            drawingStatus.addStatus(pointToText,

                                getTextSymbol(colorToTextSymbol), String.valueOf(i++));

                        }

                    }

                }

            } else {

                Geometry selectedGeometry = getSelectedGeometry();

                if (selectedVertex == null) {

                    List<Point> vertexesList =

                        getVertexesList(selectedGeometry);

                    Point vertex =

                        getVertex(selectedGeometry, mousePosition, tolerance);

                    if (vertexesList != null) {

                        int i = 0;

                        int selectedIndex = -1;

                        for (Iterator<Point> iterator = vertexesList.iterator(); iterator

                            .hasNext();) {

                            Point point = (Point) iterator.next();

                            Point pointToText = (Point) point.cloneGeometry();

                            pointToText.transform(new AffineTransform(1, 0, 0,

                                1, translationForTextSymbol, 0));

                            if (vertex != null && vertex.equals(point)) {

                                if(selectedIndex<0){

                                    selectedIndex = i++;

                                } else {

                                    i++;

                                }

                            } else {

                                drawingStatus.addStatus(point,

                                    selectedVertexSymbolEditing, "");

                                drawingStatus

                                .addStatus(

                                    pointToText,

                                    getTextSymbol(colorToTextSymbol),

                                    String.valueOf(i++));

                            }

                        }

                        if (selectedIndex >= 0) {

                            Point pointToText = (Point) vertex.cloneGeometry();

                            pointToText.transform(new AffineTransform(1, 0, 0,

                                1, translationForTextSymbol, 0));

                            drawingStatus.addStatus(vertex,

                                editedVertexSymbolEditing, "");

                            drawingStatus

                                .addStatus(pointToText,

                                    getTextSymbol(colorToTextSymbol),

                                    createInfoPointMessage(pointToText, selectedIndex)

                                    );

                        }

                    }

                } else {

                    List<Point> vertexesList =

                        getVertexesList(selectedGeometry);

                    if (vertexesList != null) {

                        int i = 0;

                        if (selectedIndex < 0) {

                            for (Iterator<Point> iterator = vertexesList.iterator(); iterator.hasNext();) {

                                Point point = (Point) iterator.next();

                                Point pointToText = (Point) point.cloneGeometry();

                                pointToText.transform(new AffineTransform(1, 0, 0, 1, translationForTextSymbol, 0));

                                if (selectedVertex.equals(point)) {

                                    if (selectedIndex < 0) {

                                        selectedIndex = i++;

                                    } else {

                                        i++;

                                    }

                                } else {

                                    drawingStatus.addStatus(point, selectedVertexSymbolEditing, "");

                                    drawingStatus.addStatus(pointToText, getTextSymbol(colorToTextSymbol),

                                        String.valueOf(i++));

                                }

                            }

                        }

                        if (selectedIndex >= 0) {

                            Point pointToText =

                                (Point) selectedVertex.cloneGeometry();

                            pointToText.transform(new AffineTransform(1, 0, 0, 1, translationForTextSymbol, 0));

                            drawingStatus.addStatus(selectedVertex,

                                editedVertexSymbolEditing, "");

                            drawingStatus

                            .addStatus(pointToText,

                                getTextSymbol(colorToTextSymbol), createInfoPointMessage(pointToText, selectedIndex));

                            Point newPosition = (Point) selectedVertex.cloneGeometry();

                            newPosition.setX(mousePosition.getX());

                            newPosition.setY(mousePosition.getY());

                            Geometry modifiedGeometry = this.getModifiedGeometry(selectedGeometry, selectedIndex, newPosition);

                            addToDrawingStatus(drawingStatus, modifiedGeometry);

                            drawingStatus.addStatus(mousePosition,

                                selectedVertexSymbolEditing, "");

                            pointToText =(Point) selectedVertex.cloneGeometry();

                            pointToText.setX(mousePosition.getX());

                            pointToText.setY(mousePosition.getY());

                            pointToText.transform(new AffineTransform(1, 0, 0, 1, translationForTextSymbol, 0));

                            drawingStatus.addStatus(pointToText,

                                getTextSymbol(colorToTextSymbol), createInfoPointMessage(pointToText, selectedIndex));

                        }

                    }

                }

            }

        } catch (BaseException e) {

            throw new DrawServiceException(e);

        }

        return drawingStatus;

    }

    private String createInfoPointMessage(Point point, int index) throws GeometryOperationNotSupportedException, GeometryOperationException{

        StringBuilder builder = new StringBuilder();

        builder.append(index);

        builder.append(" ");

        builder.append(point.convertToWKT().replaceAll("POINT ", "").replaceAll(" ", " , "));

        return builder.toString();

    }

    private void addToDrawingStatus(DefaultDrawingStatus drawingStatus,

        Geometry geometry) throws CreateGeometryException, GeometryOperationNotSupportedException, GeometryOperationException {

        if (geometry instanceof MultiPrimitive) {

            MultiPrimitive aggregate = (MultiPrimitive) geometry;

            for (int i = 0; i < aggregate.getPrimitivesNumber(); i++) {

                Primitive primitive = aggregate.getPrimitiveAt(i);

                EditVertexOperation operation =

                    EditVertexOperationUtils.getOperation(primitive);

                if (operation != null) {

                    operation.addToDrawingStatus(drawingStatus, primitive);

                }

            }

        } else if (geometry instanceof Primitive) {

            Primitive primitive = (Primitive) geometry;

            EditVertexOperation operation =

                EditVertexOperationUtils.getOperation(primitive);

            if (operation != null) {

                operation.addToDrawingStatus(drawingStatus, primitive);

            }

        }

        return;

    }

    private Geometry getModifiedGeometry(Geometry geometry, int index,

        Point newPosition) throws CreateGeometryException,

        GeometryOperationNotSupportedException, GeometryOperationException {

        if (geometry instanceof MultiPrimitive) {

            GeometryManager geometryManager =

                GeometryLocator.getGeometryManager();

            MultiPrimitive aggregate = (MultiPrimitive) geometry;

            GeometryType geometryType = aggregate.getGeometryType();

            MultiPrimitive newAggregate =

                (MultiPrimitive) geometryManager.create(geometryType.getType(),

                    geometryType.getSubType());

            for (int i = 0; i < aggregate.getPrimitivesNumber(); i++) {

                Primitive primitive = aggregate.getPrimitiveAt(i);

                EditVertexOperation operation =

                    EditVertexOperationUtils.getOperation(primitive);

                if (operation != null) {

                    int numVertexes = operation.getNumVertex(primitive);

                    if (index > -1 && index < numVertexes) {

                        Geometry modifiedPrimitive =

                            operation.moveVertex(primitive, index,

                                newPosition);

                        newAggregate

                            .addPrimitive((Primitive) modifiedPrimitive);

                        index = -1;

                    } else {

                        index -= numVertexes;

                        newAggregate.addPrimitive((Primitive) primitive

                            .cloneGeometry());

                    }

                }

            }

            return newAggregate;

        } else if (geometry instanceof Primitive) {

            Primitive primitive = (Primitive) geometry;

            EditVertexOperation operation =

                EditVertexOperationUtils.getOperation(primitive);

            if (operation != null) {

                return operation.moveVertex(primitive, index, newPosition);

            }

        }

        return null;

    }

    private Geometry getInsertVertexGeometry(Geometry geometry, int index)

        throws CreateGeometryException {

        if (geometry instanceof MultiPrimitive) {

            GeometryManager geometryManager =

                GeometryLocator.getGeometryManager();

            MultiPrimitive aggregate = (MultiPrimitive) geometry;

            GeometryType geometryType = aggregate.getGeometryType();

            MultiPrimitive newAggregate =

                (MultiPrimitive) geometryManager.create(geometryType.getType(),

                    geometryType.getSubType());

            for (int i = 0; i < aggregate.getPrimitivesNumber(); i++) {

                Primitive primitive = aggregate.getPrimitiveAt(i);

                EditVertexOperation operation =

                    EditVertexOperationUtils.getOperation(primitive);

                if (operation != null) {

                    int numVertexes = operation.getNumVertex(primitive);

                    if (index > -1 && index < numVertexes) {

                        Geometry modifiedPrimitive =

                            operation.insertVertex(primitive, index);

                        newAggregate

                            .addPrimitive((Primitive) modifiedPrimitive);

                        index = -1;

                    } else {

                        index -= numVertexes;

                        newAggregate.addPrimitive((Primitive) primitive

                            .cloneGeometry());

                    }

                }

            }

            return newAggregate;

        } else if (geometry instanceof Primitive) {

            Primitive primitive = (Primitive) geometry;

            EditVertexOperation operation =

                EditVertexOperationUtils.getOperation(primitive);

            if (operation != null) {

                return operation.insertVertex(primitive, index);

            }

        }

        return null;

    }

    private Geometry getRemovedVertexGeometry(Geometry geometry, int index)

        throws CreateGeometryException {

        if (geometry instanceof MultiPrimitive) {

            GeometryManager geometryManager =

                GeometryLocator.getGeometryManager();

            MultiPrimitive aggregate = (MultiPrimitive) geometry;

            GeometryType geometryType = aggregate.getGeometryType();

            MultiPrimitive newAggregate =

                (MultiPrimitive) geometryManager.create(geometryType.getType(),

                    geometryType.getSubType());

            for (int i = 0; i < aggregate.getPrimitivesNumber(); i++) {

                Primitive primitive = aggregate.getPrimitiveAt(i);

                EditVertexOperation operation =

                    EditVertexOperationUtils.getOperation(primitive);

                if (operation != null) {

                    int numVertexes = operation.getNumVertex(primitive);

                    if (index > -1 && index < numVertexes) {

                        Geometry modifiedPrimitive =

                            operation.removeVertex(primitive, index);

                        newAggregate

                            .addPrimitive((Primitive) modifiedPrimitive);

                        index = -1;

                    } else {

                        index -= numVertexes;

                        newAggregate.addPrimitive((Primitive) primitive

                            .cloneGeometry());

                    }

                }

            }

            return newAggregate;

        } else if (geometry instanceof Primitive) {

            Primitive primitive = (Primitive) geometry;

            EditVertexOperation operation =

                EditVertexOperationUtils.getOperation(primitive);

            if (operation != null) {

                return operation.removeVertex(primitive, index);

            }

        }

        return null;

    }

    private ISimpleTextSymbol getTextSymbol(Color color){

        SymbologyManager symbologyManager = SymbologyLocator.getSymbologyManager();

        ISimpleTextSymbol textSymbol = symbologyManager.createSimpleTextSymbol();

        textSymbol.setFontSize(12);

        textSymbol.setColor(color);

        return textSymbol;

    }

    public void stop() throws StopServiceException {

        this.selection = null;

        this.selectedVertex = null;

        this.pointToMove = null;

        this.action = null;

    }

    public List<EditingServiceParameter> getParameters() {

        List<EditingServiceParameter> parameters =

            new ArrayList<EditingServiceParameter>();

        parameters.add(selectionParameter);

        parameters.add(vertexSelectionPointParameter);

        parameters.add(actionParameter);

        return parameters;

    }

    public void setValue(Object value) throws InvalidEntryException {

        EditingServiceParameter parameter = next();

        validateAndInsertValue(parameter, value);

    }

    private void validateAndInsertValue(

        final EditingServiceParameter parameter, Object value)

        throws InvalidEntryException {

        if (parameter == selectionParameter) {

            if (value instanceof FeatureSelection) {

                FeatureSelection featureSelection = (FeatureSelection) value;

                if (featureSelection.getSelectedCount() == 1) {

                    this.selection = featureSelection;

                } else {

                    throw new InvalidEntryException(null);

                }

            }

        } else {

            Geometry selectedGeometry;

            try {

                selectedGeometry = getSelectedGeometry();

            } catch (DataException e1) {

                throw new InvalidEntryException(e1);

            }

            if (parameter == vertexSelectionPointParameter) {

                if (value instanceof Point) {

                    Point point = (Point) value;

                    double tolerance = mapContext.getViewPort().toMapDistance(TOLERANCE_PIXELS);

                    try {

                        this.selectedVertex = getVertex(selectedGeometry, point, tolerance);

                        selectedIndex = getSelectedIndex(getVertexesList(selectedGeometry));

                    } catch (BaseException e) {

                        throw new InvalidEntryException(e);

                    }

                    return;

                } else if (value instanceof Double) {

                    Double index = (Double) value;

                    if (index != Math.round(index)) {

                        throw new InvalidEntryException(null);

                    } else {

                        List<Point> vertexesList;

                        try {

                            vertexesList = getVertexesList(selectedGeometry);

                        } catch (BaseException e) {

                            throw new InvalidEntryException(e);

                        }

                        if(index >= vertexesList.size()){

                            throw new InvalidEntryException(null);

                        }

                        this.selectedIndex = index.intValue();

                        this.selectedVertex = vertexesList.get(this.selectedIndex);

                    }

                }

            } else if (parameter == actionParameter) {

                if (value instanceof Point) {

                    this.pointToMove = (Point) value;

                } else if (value instanceof String) {

                    List<Point> vertexesList;

                    try {

                        vertexesList = getVertexesList(selectedGeometry);

                    } catch (BaseException e) {

                        throw new InvalidEntryException(e);

                    }

                    EditVertexOperation operation = null;

                    if (vertexesList != null) {

                        Primitive primitive = null;

                        if (selectedIndex < 0) {

                            if (selectedGeometry instanceof MultiPrimitive) {

                                MultiPrimitive aggregate = (MultiPrimitive) selectedGeometry;

                                boolean found = false;

                                for (int i = 0; i < aggregate.getPrimitivesNumber(); i++) {

                                    // selectedIndex = -1;

                                    primitive = aggregate.getPrimitiveAt(i);

                                    operation = EditVertexOperationUtils.getOperation(primitive);

                                    if (operation != null) {

                                        int numVertexes = operation.getNumVertex(primitive);

                                        if (primitive instanceof OrientablePrimitive) {

                                            OrientablePrimitive orientable = (OrientablePrimitive) primitive;

                                            for (int j = 0; j < numVertexes; j++) {

                                                if (selectedVertex.equals(orientable.getVertex(j))) {

                                                    selectedIndex = j;

                                                    found = true;

                                                    break;

                                                }

                                            }

                                        }

                                    }

                                    if (found) {

                                        break;

                                    }

                                }

                            }

                        } else if (selectedGeometry instanceof Primitive) {

                            primitive = (Primitive) selectedGeometry;

                            if (selectedIndex < 0) {

                                operation = EditVertexOperationUtils.getOperation(primitive);

                                if (operation != null) {

                                    int numVertexes = operation.getNumVertex(primitive);

                                    if (primitive instanceof OrientablePrimitive) {

                                        OrientablePrimitive orientable = (OrientablePrimitive) primitive;

                                        for (int j = 0; j < numVertexes; j++) {

                                            if (selectedVertex.equals(orientable.getVertex(j))) {

                                                selectedIndex = j;

                                                break;

                                            }

                                        }

                                    }

                                }

                            }

                        }

                        String str = (String) value;

                        if (str.equalsIgnoreCase("+") || str.equalsIgnoreCase("-")) {

                            if (operation != null) {

                                if (str.equalsIgnoreCase("+")) {

                                    if (selectedIndex < 0 || !operation.canInsertVertex(primitive, selectedIndex)) {

                                        throw new InvalidEntryException(null);

                                    }

                                } else if (str.equalsIgnoreCase("-")) {

                                    if (selectedIndex < 0 || !operation.canRemoveVertex(primitive, selectedIndex)) {

                                        throw new InvalidEntryException(null);

                                    }

                                }

                            }

                            this.action = str;

                        } else {

                            if (str.equalsIgnoreCase("z")) {

                            } else {

                                throw new InvalidEntryException(null);

                            }

                        }

                    }

                } else if (value instanceof Double) {

                    this.pointToMove = (Point) selectedVertex.cloneGeometry();

                    this.pointToMove.setCoordinateAt(2, (Double) value);

                }

            }

        }

    }

    private Point getVertex(Geometry geometry, Point point, double tolerance)

        throws GeometryOperationNotSupportedException,

        GeometryOperationException, CreateGeometryException {

        List<Point> vertexesList = getVertexesList(geometry);

        double min = Double.POSITIVE_INFINITY;

        Point vertex = null;

        if (vertexesList != null) {

            for (Iterator<Point> iterator = vertexesList.iterator(); iterator

                .hasNext();) {

                Point point2 = (Point) iterator.next();

                double distance = getDistance(point, point2);

                if (distance <= tolerance) {

                    if (distance < min) {

                        vertex = point2;

                        min = distance;

                    }

                }

            }

        }

        return vertex;

    }

    private double getDistance(Point p1, Point p2) throws GeometryOperationNotSupportedException, GeometryOperationException, CreateGeometryException{

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        if(p1.getDimension()==p2.getDimension()){

            return p1.distance(p2);

        } else {

            Point auxP1 = geomManager.createPoint(p1.getX(), p1.getY(), Geometry.SUBTYPES.GEOM2D);

            Point auxP2 = geomManager.createPoint(p2.getX(), p2.getY(), Geometry.SUBTYPES.GEOM2D);

            return auxP1.distance(auxP2);

        }

    }

    private List<Point> getVertexesList(Geometry geometry) throws CreateGeometryException, GeometryOperationNotSupportedException, GeometryOperationException {

        if (geometry instanceof MultiPrimitive) {

            MultiPrimitive aggregate = (MultiPrimitive) geometry;

            List<Point> vertexesList = new ArrayList<Point>();

            for (int i = 0; i < aggregate.getPrimitivesNumber(); i++) {

                Primitive primitive = aggregate.getPrimitiveAt(i);

                EditVertexOperation operation =

                    EditVertexOperationUtils.getOperation(primitive);

                if (operation != null) {

                    vertexesList.addAll(operation.getVertexesList(primitive));

                }

            }

            return vertexesList;

        } else if (geometry instanceof Primitive) {

            Primitive primitive = (Primitive) geometry;

            EditVertexOperation operation =

                EditVertexOperationUtils.getOperation(primitive);

            if (operation != null) {

                List<Point> vertexesList = operation.getVertexesList(primitive);

                return vertexesList;

            }

        }

        return null;

    }

    private FeatureSet getGeometryByBuffer(Geometry buffer)

        throws DataException {

        FeatureQuery queryByGeometry = featureStore.createFeatureQuery();

        // Get default SRS of default feature type

        IProjection defaultSRS =

            this.featureStore.getDefaultFeatureType().getDefaultSRS();

        // Name of default geometry type

        String geomName =

            featureStore.getDefaultFeatureType()

                .getDefaultGeometryAttributeName();

        IntersectsGeometryEvaluator iee =

            new IntersectsGeometryEvaluator(buffer, defaultSRS,

                featureStore.getDefaultFeatureType(), geomName);

        queryByGeometry.setFilter(iee);

        queryByGeometry.setAttributeNames(null);

        return this.featureStore.getFeatureSet(queryByGeometry);

    }

    private Geometry getNearestGeometry(final Point point) throws GeometryOperationNotSupportedException, GeometryOperationException, DataException{

        double tolerance =

            mapContext.getViewPort().toMapDistance(TOLERANCE_PIXELS);

        Geometry buffer = point.buffer(tolerance);

        FeatureSet featureSet = getGeometryByBuffer(buffer);

        double min = Double.POSITIVE_INFINITY;

        Geometry geometry = null;

        DisposableIterator iterator = featureSet.fastIterator();

        while (iterator.hasNext()) {

            Feature feat = (Feature) iterator.next();

            double distance = point.distance(feat.getDefaultGeometry());

            if (distance < min){

                geometry = feat.getDefaultGeometry();

                min = distance;

            }

        }

        iterator.dispose();

        return geometry;

    }

    private Geometry getSelectedGeometry() throws DataException {

        Geometry selectedGeometry = null;

            if (this.selection != null && this.selection.getSelectedCount() == 1) {

                DisposableIterator it = this.selection.fastIterator();

                while (it.hasNext()) {

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

                    selectedGeometry = feature.getDefaultGeometry();

                }

                it.dispose();

            }

        return selectedGeometry;

    }

    public Geometry finish() throws FinishServiceException {

        return null;

    }

    public void finishAndStore() throws FinishServiceException {

        if (this.selection != null) {

            try {

                Geometry selectedGeometry = getSelectedGeometry();

                List<Point> vertexesList;

                vertexesList = getVertexesList(selectedGeometry);

                if(vertexesList != null){

                    if(selectedIndex<0){

                        selectedIndex = getSelectedIndex(vertexesList);

                    }

                    Geometry modifiedGeometry = null;

                    if (pointToMove != null) {

                        if (selectedIndex >= 0) {

                            modifiedGeometry =

                                this.getModifiedGeometry(selectedGeometry,

                                    selectedIndex, pointToMove);

                        }

                    } else if (action != null){

                        if(action.equalsIgnoreCase("+")){

                            modifiedGeometry =

                                this.getInsertVertexGeometry(selectedGeometry, selectedIndex);

                        } else if(action.equalsIgnoreCase("-")){

                            modifiedGeometry = this.getRemovedVertexGeometry(selectedGeometry, selectedIndex);

                        }

                    }

                    DisposableIterator it = null;

                    try {

                        it = selection.fastIterator();

                        while (it.hasNext()) {

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

                            EditableFeature editableFeature =

                                feature.getEditable();

                            editableFeature.setDefaultGeometry(modifiedGeometry);

                            ((EditingProviderServices) getProviderServices())

                                .updateFeatureInFeatureStore(

                                    editableFeature, featureStore);

                        }

                    } catch (BaseException e) {

                        throw new FinishServiceException(e);

                    } finally {

                        it.dispose();

                    }

                }

            } catch (BaseException e) {

                throw new FinishServiceException(e);

            }

        }

    }

    private int getSelectedIndex(List<Point> vertexesList) {

        int selectedIndex = -1;

        if (vertexesList != null) {

            int i = 0;

            if (selectedVertex != null) {

                for (Iterator<Point> iterator = vertexesList.iterator(); iterator.hasNext();) {

                    Point point = (Point) iterator.next();

                    if (selectedVertex.equals(point)) {

                        selectedIndex = i;

                        break;

                    }

                    i++;

                }

            }

        }

        return selectedIndex;

    }

    public void start() throws StartServiceException, InvalidEntryException {

        FeatureSelection selected = null;

        if (featureStore != null) {

            try {

                selected = featureStore.getFeatureSelection();

                long selectedCount = selected.getSelectedCount();

                if(selectedCount==1){

                    this.selection = selected;

                } else {

                    selected.deselectAll();

                }

            } catch (DataException e) {

                throw new StartServiceException(e);

            }

        }

    }

    public String getName() {

        return EditVertexEditingProviderFactory.PROVIDER_NAME;

    }

}