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

import java.util.ArrayList;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import org.gvsig.euclidean.EuclideanManager;

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

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

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

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

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

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

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

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

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

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.rendering.symbols.ISymbol;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.i18n.I18nManager;

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

import org.gvsig.tools.util.ToolsUtilLocator;

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

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;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class PolylineEditingProvider extends AbstractEditingProvider implements EditingProvider {

    private static final Logger LOGGER = LoggerFactory.getLogger(PolylineEditingProvider.class);

    protected EditingProviderServices editingProviderServices = (EditingProviderServices) getProviderServices();

    protected EditingServiceParameter points;

    protected Map<String, String> options;

    private boolean arcMode;

    private boolean finishPolyline;

    private boolean closeGeometry;

    private List<MyPolyLinePoint> values;

    protected FeatureStore featureStore;

    public PolylineEditingProvider(ProviderServices providerServices, DynObject parameters) {

        super(providerServices);

        // Initialize all provider variables.

        this.featureStore = (FeatureStore) parameters.getDynValue(EditingProviderFactory.FEATURE_STORE_FIELD);

        I18nManager i18nManager = ToolsLocator.getI18nManager();

        options = new LinkedHashMap<>();

        options.put(i18nManager.getTranslation("key_arc_mode"), "arc_mode");

        options.put(i18nManager.getTranslation("key_line_mode"), "line_mode");

        options.put(i18nManager.getTranslation("key_close"), "close_polyline");

        options.put(i18nManager.getTranslation("key_finish"), "finish");

        options.put(i18nManager.getTranslation("key_remove_last_point"), "remove_last_point");

        String consoleMsg = editingProviderServices.makeConsoleMessage("indicate_new_point", options);

        points =

            new DefaultEditingServiceParameter("insert_point", consoleMsg, options, TYPE.LIST_POSITIONS, TYPE.OPTION);

        arcMode = false;

        finishPolyline = false;

        closeGeometry = false;

    }

    /**

     * Calculates polyline with stored values and last position received as

     * parameter.If last position is null calculates only with stored values.

     *

     * @param lastPosition

     *            of polyline.

     * @return A drawing status value with a list of geometries. See

     *         {@link DrawingStatus#getGeometries()}.

     * @throws org.gvsig.vectorediting.lib.api.exceptions.VectorEditingException

     * @throws org.gvsig.fmap.geom.exception.CreateGeometryException

     * @throws org.gvsig.fmap.dal.exception.DataException

     */

    protected Line calculatePolyline(Point lastPosition) throws VectorEditingException, CreateGeometryException, DataException {

        DefaultDrawingStatus drawingStatus = new DefaultDrawingStatus();

        return calculatePolyline(lastPosition, drawingStatus);

    }

    protected Line calculatePolyline(Point lastPosition, DefaultDrawingStatus drawingStatus) throws VectorEditingException, CreateGeometryException, DataException {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        GeometryType storeGeomType = editingProviderServices.getGeomType(featureStore);

        Line line = geomManager.createLine(storeGeomType.getSubType());

        Line previewLine = geomManager.createLine(storeGeomType.getSubType());

        EuclideanManager euclideanManager = ToolsUtilLocator.getEuclideanManager();

        EditingProviderManager editingProviderManager = EditingProviderLocator.getProviderManager();

        ISymbol previewSymbol = this.getPreviewSymbol();

//        drawingStatus.setPreviewSymbol(previewSymbol);

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

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

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

        Point antPoint = null;

        Double antm = null;

        Double antb = null;

        Double m = null;

        Double b = null;

        Point center = null;

        double radius = 0.0;

        double startAngle = 0.0;

        double endAngle = 0.0;

        double angleExt = 0.0;

        double sweepAngle = 0.0;

        boolean right = false;

        boolean addGeom = false;

        Curve lineAntPointToPoint = null;

        Point point = null;

        Point nextPoint = null;

        if (values.size() > 0) {

            for (int i = 0; i < values.size(); i++) {

                MyPolyLinePoint polyLinePoint = values.get(i);

                MyPolyLinePoint polyLineNextPoint = getNextPoint(i);

                point = polyLinePoint.getPoint();

                previewLine.addVertex(point);

                line.addVertex(point);

                if (polyLineNextPoint == null) {

                    nextPoint = lastPosition;

                    addGeom = true;

                } else {

                    nextPoint = polyLineNextPoint.getPoint();

                }

                if (nextPoint == null) {

                    drawingStatus.addStatus(previewLine, lineSymbolEditing, "");

                    drawingStatus.addStatus(previewLine, previewSymbol, "");

                    if(line.getNumVertices()>1){

                        return line;

                    } else {

                        return null;

                    }

                }

                try {

                    if (polyLinePoint.isArcMode()) {

                        int subtype = editingProviderServices.getSubType(featureStore);

                        lineAntPointToPoint = GeometryUtils.createLine(point, nextPoint, subtype);

                        Double[] lineParams = editingProviderServices.getLineParams(point, nextPoint);

                        m = lineParams[0];

                        b = lineParams[1];

                        Point[] pointPerpendicular =

                            editingProviderServices.getPerpendicular(antm, antb, point, subtype);

                        Line linePointPerpendicular = geomManager.createLine(subtype);

                        linePointPerpendicular.setPoints(pointPerpendicular[0], pointPerpendicular[1]);

                        Point midPoint = editingProviderServices.getMidPoint(point, nextPoint, subtype);

                        Point[] bisector = editingProviderServices.getPerpendicular(m, b, midPoint, subtype);

                        Line lineBisector = geomManager.createLine(subtype);

                        lineBisector.setPoints(bisector[0], bisector[1]);

                        center = editingProviderServices.getIntersection(bisector, pointPerpendicular, subtype);

                        double coefDirection = 1.0;

                        if(antPoint != null){

                            coefDirection = GeometryUtils.getCoefDirection(antPoint, point, nextPoint);

                        }

                        if (center != null) {

                            startAngle = GeometryUtils.calculateAngle(center, point);

                            radius = center.distance(point);

                            //calculate sweepAngle

                            sweepAngle = GeometryUtils.calculateAngle(center, point, nextPoint);

                            if (coefDirection < 0) {

                                sweepAngle = -(2 * Math.PI - sweepAngle);

                            }

                            if (Math.signum(coefDirection) != Math.signum(sweepAngle)) {

                                sweepAngle = -(2 * Math.PI - sweepAngle);

                            }

                        } else {

                            String msg

                                    =

                                String.format("Can't get intersection between bisector" + " [(%1$s,%2$s),(%3$s,%4$s)]"

                                    + " and perperdicular" + " [(%5$s,%6$s),(%7$s,%8$s)]", bisector[0].getX(),

                                    bisector[0].getY(), bisector[1].getX(), bisector[1].getY(),

                                    pointPerpendicular[0].getX(), pointPerpendicular[0].getY(),

                                    pointPerpendicular[1].getX(), pointPerpendicular[1].getY());

                            throw new DrawServiceException(msg, null);

                        }

                        Arc arco = GeometryUtils.createArc(

                                center,

                                radius,

                                startAngle,

                                sweepAngle,

                                GEOM2D);

                        antPoint = GeometryUtils.createPoint(center, radius, startAngle+sweepAngle-(sweepAngle/1000));

                        antm = -(nextPoint.getX() - center.getX()) / (nextPoint.getY() - center.getY());

                        if (antm == Double.POSITIVE_INFINITY) {

                            antb = Double.NEGATIVE_INFINITY;

                            if (nextPoint.getX() == 0) {

                                antb = 0.0;

                            }

                        } else if (antm == Double.NEGATIVE_INFINITY) {

                            antb = Double.POSITIVE_INFINITY;

                            if (nextPoint.getX() == 0) {

                                antb = 0.0;

                            }

                        } else {

                            antb = nextPoint.getY() - (antm * nextPoint.getX());

                        }

                        // Draw geometries.

                        if (addGeom) {

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

                            drawingStatus.addStatus(nextPoint, auxiliaryPointSymbolEditing, "");

                            drawingStatus.addStatus(center, auxiliaryPointSymbolEditing, "");

                            drawingStatus.addStatus(lineAntPointToPoint, auxiliaryLineSymbolEditing, "");

                        }

                        Point vertexAnt = null;

                        MultiLine multiline = arco.toLines();

                        for (int n = 0; n < multiline.getPrimitivesNumber(); n++) {

                            Line arcLine = (Line) multiline.getPrimitiveAt(n);

                            if (arcLine.getNumVertices() > 0 && vertexAnt != null && arcLine.getVertex(0) != vertexAnt) {

                                arcLine.flip();

                            }

                            for (int j = 0; j < arcLine.getNumVertices()-1; j++) {

                                if ((vertexAnt == null) || !vertexAnt.equals(arcLine.getVertex(j))) {

                                    line.addVertex(arcLine.getVertex(j));

                                    previewLine.addVertex(arcLine.getVertex(j));

                                    vertexAnt = arcLine.getVertex(j);

                                }

                            }

                            nextPoint = arcLine.getVertex(arcLine.getNumVertices()-1);

                        }

                    } else {

                        int subtype = editingProviderServices.getSubType(featureStore);

                        if (addGeom) {

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

                            drawingStatus.addStatus(nextPoint, auxiliaryPointSymbolEditing, "");

                        }

                        antPoint = point;

                        //FIXME: Esto es para el c?lculo del posible arco posterior.

                        Double[] antLineParams = editingProviderServices.getLineParams(point, nextPoint);

                        antm = antLineParams[0];

                        antb = antLineParams[1];

                        right = (nextPoint.getX() >= point.getX());

                    }

                } catch (Exception e) {

                    throw new DrawServiceException(e);

                }

            }

            if(nextPoint != null) {

                line.addVertex(nextPoint);

                previewLine.addVertex(nextPoint);

                nextPoint = null;

            }

            drawingStatus.addStatus(previewLine, lineSymbolEditing, "");

            drawingStatus.addStatus(previewLine, previewSymbol, "");

            if(line.getNumVertices()>1){

                return line;

            } else {

                return null;

            }

        }

        return null;

    }

    protected Geometry closeGeometryIfNecessary(Geometry geometry) {

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

            if (geometry instanceof Surface) {

                Surface surface = (Surface) geometry;

                Point firstp = surface.getVertex(0);

                firstp = (Point) firstp.cloneGeometry();

                surface.addVertex(firstp);

                return surface;

            } else if (geometry instanceof Curve) {

                Curve line = (Curve) geometry;

                Point firstp = line.getVertex(0);

                firstp = (Point) firstp.cloneGeometry();

                line.addVertex(firstp);

                return line;

            }

        }

        return geometry;

    }

    @Override

    public DrawingStatus getDrawingStatus(Point mousePosition) throws DrawServiceException {

        try {

            DefaultDrawingStatus drawingStatus = new DefaultDrawingStatus();

            Geometry geom = calculatePolyline(mousePosition, drawingStatus);

            return drawingStatus;

        } catch (Exception e) {

            throw new DrawServiceException(e);

        }

    }

    @Override

    public void finishAndStore() throws FinishServiceException {

        try {

            Geometry geometry = finish();

            if (geometry != null) {

                editingProviderServices.insertGeometryIntoFeatureStore(geometry, featureStore);

            }

        } catch (Exception e) {

            throw new FinishServiceException(e);

        }

    }

    @Override

    public Geometry finish() throws FinishServiceException {

        try {

            GeometryManager geomManager = GeometryLocator.getGeometryManager();

            GeometryType storeGeomType = editingProviderServices.getGeomType(featureStore);

            Line line = calculatePolyline(null);

            if(line == null){

                return null;

            }

            if (closeGeometry) {

                line = (Line) closeGeometryIfNecessary(line);

            }

            if (storeGeomType.isTypeOf(MULTICURVE)) {

                MultiCurve multiCurve = geomManager.createMultiCurve(storeGeomType.getSubType());

                multiCurve.addCurve(line);

                return multiCurve;

            } else {

                return line;

            }

        } catch (BaseException e) {

            throw new FinishServiceException(e);

        }

    }

    @Override

    public String getName() {

        return PolylineEditingProviderFactory.PROVIDER_NAME;

    }

    private MyPolyLinePoint getNextPoint(int i) {

        if (!values.isEmpty() && (i < (values.size() - 1))) {

            return values.get(i + 1);

        }

        return null;

    }

    private MyPolyLinePoint getPreviousPoint(int i) {

        if (!values.isEmpty() && (i > 0)) {

            return values.get(i - 1);

        }

        return null;

    }

    @Override

    public List<EditingServiceParameter> getParameters() {

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

        list.add(points);

        return list;

    }

    private boolean isClose(Geometry geometry) {

        if (geometry != null) {

            if (geometry instanceof OrientablePrimitive) {

                OrientablePrimitive orientablePrimitive = (OrientablePrimitive) geometry;

                Point firstPoint = orientablePrimitive.getVertex(0);

                Point lastPoint = orientablePrimitive.getVertex(orientablePrimitive.getNumVertices() - 1);

                if (firstPoint.equals(lastPoint)) {

                    return true;

                }

            }

        }

        return false;

    }

    @Override

    public EditingServiceParameter next() {

        if (finishPolyline) {

            return null;

        } else {

            return points;

        }

    }

    @Override

    public void start() throws StartServiceException {

        // Stop service;

        stop();

        values = new ArrayList<>();

    }

    @Override

    public void stop() {

        if (values != null) {

            values.clear();

        }

        arcMode = false;

        finishPolyline = false;

        closeGeometry = false;

    }

    private void validateAndInsertValue(EditingServiceParameter param, Object value) throws InvalidEntryException {

        if (value instanceof String) {

            String option = (String) value;

            I18nManager i18nManager = ToolsLocator.getI18nManager();

            if (option.equalsIgnoreCase(i18nManager.getTranslation("key_finish"))) {

                finishPolyline = true;

                return;

            }

            if (values.size() > 0) {

                if (option.equalsIgnoreCase(i18nManager.getTranslation("key_remove_last_point"))) {

                    arcMode = values.get(values.size() - 1).isArcMode();

                    if (values.size() > 2) {

                        values.get(values.size() - 2).setArcMode(arcMode);

                    } else {

                        arcMode = false;

                    }

                    values.remove(values.size() - 1);

                    return;

                }

            }

            if (values.size() >= 2) {

                if (option.equalsIgnoreCase(i18nManager.getTranslation("key_arc_mode"))) {

                    arcMode = true;

                } else if (option.equalsIgnoreCase(i18nManager.getTranslation("key_line_mode"))) {

                    arcMode = false;

                } else if (option.equalsIgnoreCase(i18nManager.getTranslation("key_close"))) {

                    closeGeometry = true;

                    finishPolyline = true;

                }

            } else {

                throw new InvalidEntryException(null);

            }

            if (values.size() > 0) {

                values.get(values.size() - 1).setArcMode(arcMode);

                return;

            }

        } else if ((param == points) && (value instanceof Point)) {

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

            values.add(new MyPolyLinePoint(vertex, arcMode));

            return;

        }

        throw new InvalidEntryException(null);

    }

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

    }

    @Override

    public Object getValue(EditingServiceParameter parameter) {

        if(parameter == points){

            return values;

        }

        return null;

    }

}