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.fmap.dal.exception.DataException;

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryException;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

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

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

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

public class PolylineEditingProvider extends AbstractEditingProvider implements EditingProvider {

    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<String, String>();

        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()}.

     */

    private DrawingStatus calculatePolyline(Point lastPosition) throws VectorEditingException {

        DefaultDrawingStatus drawingStatus = 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");

        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;

        boolean right = false;

        boolean addGeom = false;

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        Curve lineAntPointToPoint = null;

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

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

                MyPolyLinePoint polyLinePoint = values.get(i);

                MyPolyLinePoint polyLineNextPoint = getNextPoint(i);

                Point point = polyLinePoint.getPoint();

                Point nextPoint;

                if (polyLineNextPoint == null) {

                    nextPoint = lastPosition;

                    addGeom = true;

                } else {

                    nextPoint = polyLineNextPoint.getPoint();

                }

                if (nextPoint == null) {

                    return drawingStatus;

                }

                try {

                    if (polyLinePoint.isArcMode()) {

                        EditingProviderServices editingProviderServices =

                            ((EditingProviderServices) getProviderServices());

                        int subtype = editingProviderServices.getSubType(featureStore);

                        lineAntPointToPoint = editingProviderServices.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);

                        if (center != null) {

                            startAngle = editingProviderServices.getAngle(center, point);

                            endAngle = editingProviderServices.getAngle(center, nextPoint);

                            radius = center.distance(point);

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

                        }

                        Double[] lineCenterNextParams = editingProviderServices.getLineParams(center, nextPoint);

                        double mcn = lineParams[0];

                        double bcn = lineParams[1];

                        if (right) {

                            if (m >= antm) {

                                    if(mcn >= antm){

                                        angleExt = -editingProviderServices.angleDistance(startAngle, endAngle);

                                    } else {

                                        angleExt = editingProviderServices.angleDistance(endAngle, startAngle);

                                    }

                                right = !(nextPoint.getY() >= center.getY());

                            } else {

                                angleExt = -editingProviderServices.angleDistance(startAngle, endAngle);

                                right = (nextPoint.getY() >= center.getY());

                            }

                        } else {

                            if (m >= antm) {

                                angleExt = editingProviderServices.angleDistance(endAngle, startAngle);

                                right = !(nextPoint.getY() >= center.getY());

                            } else {

                                angleExt = -editingProviderServices.angleDistance(startAngle, endAngle);

                                right = (nextPoint.getY() >= center.getY());

                            }

                        }

                        Arc arco = null;

                        arco = editingProviderServices.createArc(center, radius, startAngle, angleExt, Geometry.SUBTYPES.GEOM2D);

//                        Arc inverseArc = (Arc) geomManager.create(Geometry.TYPES.ARC, subtype);

//                        inverseArc.setPoints(arco.getEndPoint(), arco.getMiddlePoint(), arco.getInitPoint());

//                        arco = inverseArc;

                        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, "");

                        }

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

                    } else {

                        int subtype = editingProviderServices.getSubType(featureStore);

                        Curve geometry = editingProviderServices.createLine(point, nextPoint, subtype);

                        if (addGeom) {

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

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

                        }

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

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

                        antm = antLineParams[0];

                        antb = antLineParams[1];

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

                    }

                } catch (Exception e) {

                    throw new DrawServiceException(e);

                }

            }

            return drawingStatus;

        }

        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;

    }

    public DrawingStatus getDrawingStatus(Point mousePosition) throws DrawServiceException {

        try {

            return calculatePolyline(mousePosition);

        } catch (Exception e) {

            throw new DrawServiceException(e);

        }

    }

    public void finishAndStore() throws FinishServiceException {

        try {

            Geometry geometry = finish();

            if (geometry != null) {

                editingProviderServices.insertGeometryIntoFeatureStore(geometry, featureStore);

            }

        } catch (Exception e) {

            throw new FinishServiceException(e);

        }

    }

    public Geometry finish() throws FinishServiceException {

        try {

            GeometryManager geomManager = GeometryLocator.getGeometryManager();

            GeometryType storeGeomType = editingProviderServices.getGeomType(featureStore);

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

            calculateFinalGeometry(storeGeomType, line);

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

        }

    }

    /**

     * Calculate the final geometry reversing the geometries of the

     * drawingStatus if needed.

     *

     * @param geometryType

     * @param orientablePrimitive

     * @throws DataException

     * @throws VectorEditingException

     * @throws GeometryException

     * @throws GeometryOperationException

     * @throws GeometryOperationNotSupportedException

     */

    protected void calculateFinalGeometry(GeometryType geometryType, OrientablePrimitive orientablePrimitive)

        throws DataException, VectorEditingException, GeometryException, GeometryOperationNotSupportedException, GeometryOperationException {

        DrawingStatus drawingStatus = calculatePolyline(null);

        Point vertexAnt = null;

        for (Geometry geometry : drawingStatus.getGeometries()) {

            if (geometry instanceof Line) {

                Line line = (Line) geometry;

                for (int i = 0; i < line.getNumVertices(); i++) {

                    if ((vertexAnt == null) || !vertexAnt.equals(line.getVertex(i))) {

                        orientablePrimitive.addVertex(line.getVertex(i));

                        vertexAnt = line.getVertex(i);

                    }

                }

            } else if(geometry instanceof Curve){

                MultiLine multiline = geometry.toLines();

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

                    Line line = (Line)multiline.getPrimitiveAt(i);

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

                        line.flip();

                    }

                    for (int j = 0; j < line.getNumVertices(); j++) {

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

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

                            vertexAnt = line.getVertex(j);

                        }

                    }

                }

            }

        }

    }

    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;

    }

    public List<EditingServiceParameter> getParameters() {

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

        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;

    }

    public EditingServiceParameter next() {

        if (finishPolyline) {

            return null;

        } else {

            return points;

        }

    }

    public void start() throws StartServiceException {

        // Stop service;

        stop();

        values = new ArrayList<MyPolyLinePoint>();

    }

    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)) {

            values.add(new MyPolyLinePoint((Point) value, arcMode));

            return;

        }

        throw new InvalidEntryException(null);

    }

    public void setValue(Object value) throws InvalidEntryException {

        EditingServiceParameter param = next();

        validateAndInsertValue(param, value);

    }

}