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 java.util.logging.Level;

import org.geotools.measure.AngleFormat;

import org.gvsig.euclidean.EuclideanLine2D;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.GeometryExpressionBuilder;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.EditingNotification;

import org.gvsig.fmap.dal.EditingNotificationManager;

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

import org.gvsig.fmap.dal.expressionevaluator.DALExpressionBuilder;

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

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

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

import org.gvsig.fmap.dal.swing.DALSwingLocator;

import org.gvsig.fmap.geom.Geometry;

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

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.GeometryUtils;

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

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

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

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

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

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

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

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 DefaultEditingProviderServices extends AbstractProviderServices

        implements EditingProviderServices {

    private static final Logger LOGGER = LoggerFactory

            .getLogger(DefaultEditingProviderServices.class);

    @Override

    public void insertFeatureIntoFeatureStore(Feature feature,

            FeatureStore featureStore) {

        EditableFeature eFeature = null;

        try {

            if (feature instanceof EditableFeature) {

                eFeature = (EditableFeature) feature;

            } else {

                eFeature = feature.getEditable();

            }

            EditingNotificationManager editingNotificationManager

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

        }

    }

    @Override

    public void insertGeometryIntoFeatureStore(Geometry geometry,

            FeatureStore featureStore) {

        EditableFeature eFeature = null;

        try {

            eFeature = featureStore.createNewFeature(true);

            eFeature.setGeometry(featureStore.getDefaultFeatureType()

                    .getDefaultGeometryAttributeName(), geometry);

            EditingNotificationManager editingNotificationManager

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

        }

    }

    @Override

    public void deleteFeatureFromFeatureSet(Feature feature,

            FeatureStore featureStore, FeatureSet set) {

        try {

            EditingNotificationManager editingNotificationManager

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

            }

            set.delete(feature);

            editingNotificationManager.notifyObservers(this,

                    EditingNotification.AFTER_REMOVE_FEATURE, null, null,

                    featureStore, feature);

        } catch (Exception e) {

            LOGGER.warn(e.getMessage(), e);

        }

    }

    @Override

    public void deleteFeatureFromFeatureStore(Feature feature,

            FeatureStore featureStore) {

        try {

            EditingNotificationManager editingNotificationManager

                    = DALSwingLocator.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) {

            LOGGER.warn(e.getMessage(), e);

        }

    }

    @Override

    public void updateFeatureInFeatureStore(Feature feature,

            FeatureStore featureStore) {

        EditableFeature eFeature = null;

        try {

            if (feature instanceof EditableFeature) {

                eFeature = (EditableFeature) feature;

            } else {

                eFeature = feature.getEditable();

            }

            EditingNotificationManager editingNotificationManager

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

        }

    }

    @Override

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

            throws CreateGeometryException {

        return GeometryUtils.createCircle(center, radius, subtype);

    }

    @Override

    public Circle createCircle(Point firstPoint, Point secondPoint,

            Point thridPoint, int subtype) throws CreateGeometryException {

        return GeometryUtils.createCircle(firstPoint, secondPoint, thridPoint, subtype);

    }

    @Override

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

            double angleExt, int subtype) throws CreateGeometryException {

        return GeometryUtils.createArc(center, radius, startAngle, angleExt, subtype);

    }

    @Override

    public Ellipse createFilledEllipse(Point firstPointAxisA,

            Point secondPointAxisA, double halfLengthAxisB, int subtype)

            throws CreateGeometryException {

        return GeometryUtils.createFilledEllipse(firstPointAxisA, secondPointAxisA, halfLengthAxisB, subtype);

    }

    @Override

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

            throws BaseException {

        return GeometryUtils.createArc(start, middle, end, subtype);

    }

    @Override

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

            throws CreateGeometryException {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        return geomManager.createPoint(x, y, subtype);

    }

    @Override

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

            int subtype) throws CreateGeometryException {

        return GeometryUtils.createLine(x1, y1, x2, y2, subtype);

    }

    @Override

    public int getSubType(FeatureStore featureStore) throws DataException {

        GeometryType geomType = getGeomType(featureStore);

        if (geomType != null) {

            return geomType.getSubType();

        }

        return SUBTYPES.UNKNOWN;

    }

    @Override

    public GeometryType getGeomType(FeatureStore featureStore)

            throws DataException {

        return featureStore.getDefaultFeatureType()

                .getDefaultGeometryAttribute().getGeomType();

    }

    @Override

    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;

    }

    @Override

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

            throws CreateGeometryException {

        return GeometryUtils.getCenter(a, b, c, subtype);

    }

    @Override

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

            throws CreateGeometryException {

        return GeometryUtils.getMidPoint(a, b, subtype);

    }

    @Override

    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;

    }

    @Override

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

            throws CreateGeometryException {

        // Pendiente de la recta perpendicular

        Double m1 = -1 / m;

        // b de la funcion de la recta perpendicular

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

        // Obtenemos un par de puntos

        Point[] res = new Point[2];

        if (Double.isInfinite(m1)) {

            if (m1 > 0) {

                //return the director vector of the line

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

                res[1] = createPoint(point.getX(), 1.0, subtype);

            } else {

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

                res[1] = createPoint(point.getX(), -1.0, subtype);

            }

        } else {

            //return the director vector of the line

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

            Double mod = Math.sqrt(1 + Math.pow(m1, 2));

            Double x = 1 / mod;

            Double y = m1 * x + b1;

            res[1] = createPoint(x, y, subtype);

        }

        return res;

    }

    @Override

    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;

    }

    @Override

    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;

    }

    @Override

    public double angleDistance(double angle1, double angle2) {

        double result = angle2 - angle1;

        if (result < 0) {

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

        }

        return result;

    }

    @Override

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

            throws CreateGeometryException {

        return GeometryUtils.createLine(p1, p2, subtype);

    }

    @Override

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

            throws CreateGeometryException {

        return GeometryUtils.createSpline(points, subtype);

    }

    @Override

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

    }

    @Override

    public Arc createEllipse(Point firstPointAxisA, Point secondPointAxisA,

            double halfLengthAxisB, int subtype) throws CreateGeometryException {

        return GeometryUtils.createEllipse(firstPointAxisA, secondPointAxisA, halfLengthAxisB, subtype);

    }

    @Override

    public Circle createCircle(Point firstPoint, Point secondPoint, Point thirdPoint, Point fourthPoint, Point fifthPoint, int subtype) throws CreateGeometryException {

        return GeometryUtils.createCircle(firstPoint, secondPoint, thirdPoint, fourthPoint, fifthPoint, subtype);

    }

    @Override

    public Circle createCircle(EuclideanLine2D line1, EuclideanLine2D line2, Point point, int subtype) throws CreateGeometryException {

        return GeometryUtils.createCircle(line1, line2, point, subtype);

    }

    @Override

    public Circle createCircle(Geometry geometry1, Geometry geometry2, double radius, Point firstPoint, Point secondPoint, int subtype) throws CreateGeometryException {

        return GeometryUtils.createCircle(geometry1, geometry2, radius, firstPoint, secondPoint, subtype);

    }

    @Override

    public Feature getFeature(Point point, FeatureStore store, MapContext mapContext) {

        Feature feature = null;

        try {

            double tolerance = mapContext.getViewPort().toMapDistance(mapContext.getLayers().getDefaultTolerance());

            Geometry buffer = point.buffer(tolerance);

            DataManager dataManager = DALLocator.getDataManager();

            DALExpressionBuilder dalBuilder = dataManager.createDALExpressionBuilder();

            GeometryExpressionBuilder builder = dalBuilder.expression();

            FeatureType featureType = store.getDefaultFeatureType();

            String filter = builder.ST_Intersects(

                    builder.geometry(

                            buffer, mapContext.getProjection()

                    ), 

                    builder.column(featureType.getDefaultGeometryAttributeName())

            ).toString();

            String sortBy = builder.ST_Distance(

                    builder.geometry(buffer), 

                    builder.column(featureType.getDefaultGeometryAttributeName())

            ).toString();

            Expression sortByExpression = ExpressionUtils.createExpression(sortBy);

            feature = store.findFirst(filter, sortByExpression, true);

        } catch (Exception ex) {

            LOGGER.warn("Can't get feature on point (" + point.getX() + "," + point.getY(), ex);

        }

        return feature;

    }

    @Override

    public Geometry getGeometry(Point point, FeatureStore store, MapContext mapContext) {

        Geometry geometry = null;

        try {

//            Feature f = getFeature(point, store, mapContext);

//            if (f != null) {

//                geometry = f.getDefaultGeometry();

//            }

            double tolerance = mapContext.getViewPort().toMapDistance(mapContext.getLayers().getDefaultTolerance());

            Geometry buffer = point.buffer(tolerance);

            FLyrVect layer = (FLyrVect) mapContext.getLayers().getLayer(store);

            SpatialCache sc = layer.getSpatialCache();

            if(sc.isOverflown()){

                LOGGER.warn("Spatial Cache overflown. Limit = "+sc.getMaxFeatures()+". You must increase limit or zoom in.");

            }

            List<Geometry> geometries = sc.query(buffer.getEnvelope());

            double minDistance = Double.POSITIVE_INFINITY;

            for (Geometry geom : geometries) {

                if(geom.intersects(buffer)){

                    double distance = geom.distance(point);

                    if(distance<minDistance){

                        minDistance = distance;

                        geometry = geom;

                    }

                }

            }

        } catch (Exception ex) {

            LOGGER.warn("Can't get geometry on point (" + point.getX() + "," + point.getY(), ex);

        }

        return geometry;

    }

    @Override

    public Geometry getGeometryOfVisibleLayers(Point point, FeatureStore store, MapContext mapContext) {

        // Search in the store itself

        Geometry geometry = this.getGeometry(point, store, mapContext);

        // Search in the store for the layers that are in edit

        if (geometry == null) {

            for (Iterator<FLayer> iterator = mapContext.getLayers().deepiterator(); iterator.hasNext();) {

                FLayer layer = iterator.next();

                if (layer instanceof FLyrVect) {

                    FLyrVect vectLayer = (FLyrVect) layer;

                    if (vectLayer.getFeatureStore() != store && vectLayer.isEditing()) {

                        geometry = this.getGeometry(point, vectLayer.getFeatureStore(), mapContext);

                        if (geometry != null) {

                            break;

                        }

                    }

                }

            }

        }

        // Search in the store for the active layers

        if (geometry == null) {

            FLayer[] activeLayers = mapContext.getLayers().getActives();

            for (FLayer activeLayer : activeLayers) {

                if (activeLayer instanceof FLyrVect) {

                    FLyrVect activeVectLayer = (FLyrVect) activeLayer;

                    if (activeVectLayer.getFeatureStore() != store && !activeVectLayer.isEditing()) {

                        geometry = this.getGeometry(point, activeVectLayer.getFeatureStore(), mapContext);

                        if (geometry != null) {

                            break;

                        }

                    }

                }

            }

        }

        return geometry;

    }

    @Override

    public void addAngleToDrawingStatus(DefaultDrawingStatus drawingStatus, ISymbol textSymbol, Point vertex, Point ray1, Point ray2, int subtype) throws CreateGeometryException, GeometryOperationNotSupportedException, GeometryOperationException {

        EditingProviderManager editingProviderManager

                = EditingProviderLocator.getProviderManager();

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

        double angleRay1 = GeometryUtils.calculateAngle(vertex, ray1);

        double angle = GeometryUtils.calculateAngle(vertex, ray1, ray2);

        double radius = vertex.distance(ray1) / 4;

        Arc auxArc = GeometryUtils.createArc(

                vertex,

                radius,

                GeometryUtils.calculateAngle(vertex, ray1),

                angle,

                subtype

        );

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

        Point measurePoint = GeometryUtils.createPoint(vertex, radius, angleRay1 + angle / 2);

//        drawingStatus.addStatus(measurePoint, textSymbol, new AngleFormat("DD?MM'").format(Math.toDegrees(angle)));

        drawingStatus.addStatus(measurePoint, textSymbol, new AngleFormat("DD.ddd?").format(Math.toDegrees(angle)));

    }

    @Override

    public EditableFeature createNewFeature(FeatureStore store){

        try {

            return store.createNewFeature();

        } catch (DataException ex) {

            throw new RuntimeException("Can't create feature", ex);

        }

    }

}