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

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.andami.messages.NotificationManager;

import org.gvsig.editing.EditingNotification;

import org.gvsig.editing.EditingNotificationManager;

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

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

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

import org.gvsig.fmap.geom.Geometry;

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

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

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

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

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

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

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

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

import org.gvsig.fmap.mapcontext.layers.CancelationException;

import org.gvsig.fmap.mapcontrol.MapControlLocator;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.i18n.I18nManager;

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

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

public class DefaultEditingProviderServices extends AbstractProviderServices

    implements EditingProviderServices {

    private static final Logger logger = LoggerFactory

        .getLogger(DefaultEditingProviderServices.class);

    protected GeometryManager geomManager = GeometryLocator

        .getGeometryManager();

    public void insertFeatureIntoFeatureStore(Feature feature,

        FeatureStore featureStore) {

        EditableFeature eFeature = null;

        try {

            if (feature instanceof EditableFeature) {

                eFeature = (EditableFeature) feature;

            } else {

                eFeature = feature.getEditable();

            }

            EditingNotificationManager editingNotificationManager =

                MapControlLocator.getEditingNotificationManager();

            EditingNotification notification =

                editingNotificationManager.notifyObservers(this, // source

                    EditingNotification.BEFORE_INSERT_FEATURE, // type

                    null,// document

                    null,// layer

                    featureStore,// store

                    eFeature// feature

                    );

            if (notification.isCanceled()) {

                String msg =

                    String

                        .format(

                            "Can't insert feature into %1$s, canceled by some observer.",

                            featureStore.getName());

                throw new CancelationException(msg, null);

            }

            if (notification.shouldValidateTheFeature()) {

                if (!editingNotificationManager.validateFeature(eFeature)) {

                    String msg =

                        String.format("%1$s is not valid", eFeature.toString());

                    throw new Exception(msg);

                }

            }

            featureStore.insert(eFeature);

            editingNotificationManager.notifyObservers(this,

                EditingNotification.AFTER_INSERT_FEATURE, null, null,

                featureStore, eFeature);

        } catch (Exception e) {

            String msg =

                String.format("Can't insert %1$s into %2$s",

                    eFeature.toString(), featureStore.getName());

            logger.info(msg, e);

        }

    }

    public void insertGeometryIntoFeatureStore(Geometry geometry,

        FeatureStore featureStore) {

        EditableFeature eFeature = null;

        try {

            eFeature = featureStore.createNewFeature(true);

            eFeature.setGeometry(featureStore.getDefaultFeatureType()

                .getDefaultGeometryAttributeName(), geometry);

            EditingNotificationManager editingNotificationManager =

                MapControlLocator.getEditingNotificationManager();

            EditingNotification notification =

                editingNotificationManager.notifyObservers(this, // source

                    EditingNotification.BEFORE_INSERT_FEATURE, // type

                    null,// document

                    null,// layer

                    featureStore,// store

                    eFeature// feature

                    );

            if (notification.isCanceled()) {

                String msg =

                    String

                        .format(

                            "Can't insert geometry into %1$s, canceled by some observer.",

                            featureStore.getName());

                throw new CancelationException(msg, null);

            }

            if (notification.shouldValidateTheFeature()) {

                if (!editingNotificationManager.validateFeature(eFeature)) {

                    String msg =

                        String.format("%1$s is not valid", eFeature.toString());

                    throw new Exception(msg);

                }

            }

            featureStore.insert(eFeature);

            editingNotificationManager.notifyObservers(this,

                EditingNotification.AFTER_INSERT_FEATURE, null, null,

                featureStore, eFeature);

        } catch (Exception e) {

            String msg =

                String.format("Can't insert %1$s into %2$s",

                    eFeature.toString(), featureStore.getName());

            logger.info(msg, e);

        }

    }

    public void deleteFeatureFromFeatureStore(Feature feature,

        FeatureStore featureStore) {

        try {

            EditingNotificationManager editingNotificationManager =

                MapControlLocator.getEditingNotificationManager();

            EditingNotification notification =

                editingNotificationManager.notifyObservers(this, // source

                    EditingNotification.BEFORE_REMOVE_FEATURE, // type

                    null,// document

                    null,// layer

                    featureStore,// store

                    feature// feature

                    );

            if (notification.isCanceled()) {

                String msg =

                    String

                        .format(

                            "Can't delete feature from %1$s, canceled by some observer.",

                            featureStore.getName());

                throw new CancelationException(msg, null);

            }

            featureStore.delete(feature);

            editingNotificationManager.notifyObservers(this,

                EditingNotification.AFTER_REMOVE_FEATURE, null, null,

                featureStore, feature);

        } catch (Exception e) {

            NotificationManager.addError(e.getMessage(), e);

        }

    }

    public void updateFeatureInFeatureStore(Feature feature,

        FeatureStore featureStore) {

        EditableFeature eFeature = null;

        try {

            if (feature instanceof EditableFeature) {

                eFeature = (EditableFeature) feature;

            } else {

                eFeature = feature.getEditable();

            }

            EditingNotificationManager editingNotificationManager =

                MapControlLocator.getEditingNotificationManager();

            EditingNotification notification =

                editingNotificationManager.notifyObservers(this, // source

                    EditingNotification.BEFORE_UPDATE_FEATURE, // type

                    null,// document

                    null,// layer

                    featureStore,// store

                    eFeature// feature

                    );

            if (notification.isCanceled()) {

                String msg =

                    String

                        .format(

                            "Can't update feature in %1$s, canceled by some observer.",

                            featureStore.getName());

                throw new CancelationException(msg, null);

            }

            if (notification.shouldValidateTheFeature()) {

                if (!editingNotificationManager.validateFeature(eFeature)) {

                    String msg =

                        String.format("%1$s is not valid", eFeature.toString());

                    throw new Exception(msg);

                }

            }

            featureStore.update(eFeature);

            editingNotificationManager.notifyObservers(this,

                EditingNotification.AFTER_UPDATE_FEATURE, null, null,

                featureStore, eFeature);

        } catch (Exception e) {

            String msg =

                String.format("Can't update %1$s in %2$s", eFeature.toString(),

                    featureStore.getName());

            logger.info(msg, e);

        }

    }

    public Circle createCircle(Point center, double radius, int subtype)

        throws CreateGeometryException {

        Circle circle = null;

        circle = (Circle) geomManager.create(TYPES.CIRCLE, subtype);

        circle.setPoints(center, radius);

        return circle;

    }

    public Circle createCircle(Point firstPoint, Point secondPoint,

        Point thridPoint, int subtype) throws CreateGeometryException {

        Circle circle = null;

        circle = (Circle) geomManager.create(TYPES.CIRCLE, subtype);

        circle.setPoints(firstPoint, secondPoint, thridPoint);

        return circle;

    }

    public Arc createArc(Point center, double radius, double startAngle,

        double angleExt, int subtype) throws CreateGeometryException {

        Arc arc = null;

        arc = (Arc) geomManager.create(TYPES.ARC, subtype);

        arc.setPoints(center, radius, startAngle, angleExt);

        return arc;

    }

    public Ellipse createFilledEllipse(Point firstPointAxisA,

        Point secondPointAxisA, double halfLengthAxisB, int subtype)

        throws CreateGeometryException {

        Ellipse ellipse = (Ellipse) geomManager.create(TYPES.ELLIPSE, subtype);

        ellipse.setPoints(firstPointAxisA, secondPointAxisA, halfLengthAxisB);

        return ellipse;

    }

    public Arc createArc(Point start, Point middle, Point end, int subtype)

        throws BaseException {

        Arc arc = (Arc)GeometryLocator.getGeometryManager().create(Geometry.TYPES.ARC, subtype);

        arc.setPoints(start, middle, end);

        return arc;

    }

    public Point createPoint(double x, double y, int subtype)

        throws CreateGeometryException {

        Point point = null;

        point = (Point) geomManager.create(TYPES.POINT, subtype);

        point.setX(x);

        point.setY(y);

        return point;

    }

    public Line createLine(double x1, double y1, double x2, double y2,

        int subtype) throws CreateGeometryException {

        Line line = null;

        line = (Line) geomManager.create(TYPES.CURVE, subtype);

        line.addVertex(x1, y1);

        line.addVertex(x2, y2);

        return line;

    }

    public int getSubType(FeatureStore featureStore) throws DataException {

        GeometryType geomType = getGeomType(featureStore);

        if (geomType != null) {

            return geomType.getSubType();

        }

        return SUBTYPES.UNKNOWN;

    }

    public GeometryType getGeomType(FeatureStore featureStore)

        throws DataException {

        return featureStore.getDefaultFeatureType()

            .getDefaultGeometryAttribute().getGeomType();

    }

    public EditableFeature getFeatureCopyWithoutPK(FeatureStore featureStore,

        Feature feature) throws DataException {

        EditableFeature editableFeature =

            featureStore.createNewFeature(feature.getType(), true);

        FeatureType type_src = feature.getType();

        @SuppressWarnings("rawtypes")

        Iterator iterator = type_src.iterator();

        FeatureType type_dest = editableFeature.getType();

        while (iterator.hasNext()) {

            FeatureAttributeDescriptor attribute_src =

                (FeatureAttributeDescriptor) iterator.next();

            FeatureAttributeDescriptor attribute_dest =

                type_dest.getAttributeDescriptor(attribute_src.getName());

            if (attribute_dest != null) {

                if (!attribute_dest.isPrimaryKey()) {

                    editableFeature.set(attribute_dest.getIndex(),

                        feature.get(attribute_src.getIndex()));

                }

            }

        }

        return editableFeature;

    }

    public Point getCenter(Point a, Point b, Point c, int subtype)

        throws CreateGeometryException {

        Point midPointAC = getMidPoint(a, c, subtype);

        Double[] lineParamsAC = getLineParams(a, c);

        Point[] bisectorAC =

            getPerpendicular(lineParamsAC[0], lineParamsAC[1], midPointAC,

                subtype);

        Point midPointBC = getMidPoint(b, c, subtype);

        Double[] lineParamsBC = getLineParams(c, b);

        Point[] bisectorBC =

            getPerpendicular(lineParamsBC[0], lineParamsBC[1], midPointBC,

                subtype);

        return getIntersection(bisectorAC, bisectorBC, subtype);

    }

    public Point getMidPoint(Point a, Point b, int subtype)

        throws CreateGeometryException {

        double x = (a.getX() + b.getX()) / 2;

        double y = (a.getY() + b.getY()) / 2;

        return createPoint(x, y, subtype);

    }

    public Double[] getLineParams(Point point, Point nextPoint) {

        Double[] lineParams = new Double[2];

        double denom = nextPoint.getX() - point.getX();

        if (denom != 0) {

            lineParams[0] = (nextPoint.getY() - point.getY()) / denom;

            lineParams[1] = point.getY() - (lineParams[0] * point.getX());

        } else {

            if (nextPoint.getY() >= point.getY()) {

                lineParams[0] = Double.POSITIVE_INFINITY;

                lineParams[1] = Double.NEGATIVE_INFINITY;

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

                    lineParams[1] = 0.0;

                }

            } else {

                lineParams[0] = Double.NEGATIVE_INFINITY;

                lineParams[1] = Double.POSITIVE_INFINITY;

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

                    lineParams[1] = 0.0;

                }

            }

        }

        return lineParams;

    }

    public Point[] getPerpendicular(Double m, Double b, Point perp, int subtype)

        throws CreateGeometryException {

        if (m == Double.POSITIVE_INFINITY) {

            Point[] res = new Point[2];

            res[0] = createPoint(0, perp.getY(), subtype);

            res[1] = createPoint(1, perp.getY(), subtype);

            return res;

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

            Point[] res = new Point[2];

            res[0] = createPoint(1, perp.getY(), subtype);

            res[1] = createPoint(0, perp.getY(), subtype);

            return res;

        } else {

            // Pendiente de la recta perpendicular

            Double m1 = -1 / m;

            // b de la funcion de la recta perpendicular

            Double b1 = perp.getY() - (m1 * perp.getX());

            // Obtenemos un par de puntos

            Point[] res = new Point[2];

            if (Double.isInfinite(m1)) {

                res[0] = createPoint(perp.getX(), 0.0, subtype);

                res[1] = createPoint(perp.getX(), perp.getY(), subtype);

            } else {

                res[0] = createPoint(0, 0.0 + b1, subtype);

                res[1] =

                    createPoint(perp.getX(), (m1 * perp.getX()) + b1, subtype);

            }

            return res;

        }

    }

    public Point getIntersection(Point[] lineA, Point[] lineB, int subtype)

        throws CreateGeometryException {

        Point p1 = lineA[0];

        Point p2 = lineA[1];

        Point p3 = lineB[0];

        Point p4 = lineB[1];

        double m1 = Double.POSITIVE_INFINITY;

        if ((p2.getX() - p1.getX()) != 0) {

            m1 = (p2.getY() - p1.getY()) / (p2.getX() - p1.getX());

        }

        double m2 = Double.POSITIVE_INFINITY;

        if ((p4.getX() - p3.getX()) != 0) {

            m2 = (p4.getY() - p3.getY()) / (p4.getX() - p3.getX());

        }

        if ((m1 == Double.POSITIVE_INFINITY)

            && (m2 == Double.POSITIVE_INFINITY)) {

            return null;

        }

        double b1 = p2.getY() - (m1 * p2.getX());

        double b2 = p4.getY() - (m2 * p4.getX());

        if ((m1 != Double.POSITIVE_INFINITY)

            && (m2 != Double.POSITIVE_INFINITY)) {

            if (m1 == m2) {

                return null;

            }

            double x = (b2 - b1) / (m1 - m2);

            return createPoint(x, (m1 * x) + b1, subtype);

        } else if (m1 == Double.POSITIVE_INFINITY) {

            double x = p1.getX();

            return createPoint(x, (m2 * x) + b2, subtype);

        } else if (m2 == Double.POSITIVE_INFINITY) {

            double x = p3.getX();

            return createPoint(x, (m1 * x) + b1, subtype);

        }

        return null;

    }

    public double getAngle(Point start, Point end)

        throws GeometryOperationNotSupportedException,

        GeometryOperationException {

        double angle =

            Math.acos((end.getX() - start.getX()) / start.distance(end));

        if (start.getY() > end.getY()) {

            angle = -angle;

        }

        if (angle < 0) {

            angle += (2 * Math.PI);

        }

        return angle;

    }

    public double angleDistance(double angle1, double angle2) {

        double result = angle2-angle1;

        if(result<0){

            result = (Math.PI *2)+result;

        }

        return result;

    }

    public Line createLine(Point p1, Point p2, int subtype)

        throws CreateGeometryException {

        return this.createLine(p1.getX(), p1.getY(), p2.getX(), p2.getY(),

            subtype);

    }

    public Spline createSpline(List<Point> points, int subtype)

        throws CreateGeometryException {

        Spline spline = null;

        spline = (Spline) geomManager.create(TYPES.SPLINE, subtype);

        for (Point point : points) {

            spline.addVertex(point);

        }

        return spline;

    }

    public String makeConsoleMessage(String preText, Map<String, String> options) {

        I18nManager i18nManager = ToolsLocator.getI18nManager();

        StringBuilder stb = new StringBuilder();

        if (preText != null) {

            stb.append(i18nManager.getTranslation(preText));

            stb.append(" ");

        }

        for (String option : options.keySet()) {

            stb.append("[");

            stb.append(option);

            stb.append("]");

            stb.append(i18nManager.getTranslation(options.get(option)));

            stb.append(" ");

        }

        return stb.toString();

    }

    public Arc createEllipse(Point firstPointAxisA, Point secondPointAxisA,

        double halfLengthAxisB, int subtype) throws CreateGeometryException {

        try {

            double lengthAxisA = secondPointAxisA.distance(firstPointAxisA);

            Point origen = this.createPoint(0, 0, subtype);

        Arc ellipse = this.createArc(

            origen,

            lengthAxisA/2,

            0,

            2*Math.PI,

            subtype);

            ellipse.scale(origen, 1, halfLengthAxisB*2/lengthAxisA);

            ellipse.rotate(this.getAngle(firstPointAxisA, secondPointAxisA), 0, 0);

            Point centerOfEllipse = this.getMidPoint(firstPointAxisA, secondPointAxisA, subtype);

            ellipse.move(centerOfEllipse.getX(), centerOfEllipse.getY());

            return ellipse;

        } catch (GeometryOperationNotSupportedException e) {

            throw new CreateGeometryException(Geometry.TYPES.ARC, subtype, e);

        } catch (GeometryOperationException e) {

            throw new CreateGeometryException(Geometry.TYPES.ARC, subtype, e);

        }

    }

}