Application: gvSIG desktop » gvSIG tools: Vector editing

		<include>org.gvsig:org.gvsig.vectorediting.lib.spi</include>

		<include>org.gvsig:org.gvsig.vectorediting.lib.prov.polyline</include>

			<dependency>

				<groupId>org.gvsig</groupId>

				<artifactId>

					org.gvsig.vectorediting.lib.prov.polyline

				</artifactId>

				<version>1.0.0-SNAPSHOT</version>

			</dependency>

import org.gvsig.vectorediting.lib.prov.polyline.PolylineEditingProviderFactory;

  AbstractAction polyline;

    JButton polylineButton = new JButton(polyline);

    paletteTools.add(polylineButton);

    menuTool.add(new JMenuItem(polyline));

        if(mapControl.hasTool("VectorEditing")){

          mapControl.setTool("VectorEditing");

        }

    polyline = new AbstractAction("PolylineAction") {

      public void actionPerformed(ActionEvent e) {

        swingManager.activateTool(PolylineEditingProviderFactory.PROVIDER_NAME,

            mapControl);

      }

    };

//    shpPath = "/home/lmarques/data/cartography/Andalucia/hidro_andalucia.shp";

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

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

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

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

    implements EditingProviderServices {

  protected GeometryManager geomManager = GeometryLocator.getGeometryManager();

  public void insertFeatureIntoFeatureStore(Feature feature,

                                            FeatureStore featureStore) {

    // TODO Auto-generated method stub

  }

  public void insertGeometryIntoFeatureStore(Geometry geometry,

                                             FeatureStore featureStore) {

    try {

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

        throw new CancelationException("");

      }

      if (!notification.shouldValidateTheFeature()) {

        if (!editingNotificationManager.validateFeature(eFeature)) {

          throw new Exception("");

        }

      }

      featureStore.insert(eFeature);

      editingNotificationManager.notifyObservers(this,

          EditingNotification.AFTER_INSERT_FEATURE, null, null, featureStore,

          eFeature);

    }

    catch (Exception e) {

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

    }

  }

  public void deleteFeatureFromFeatureStore(Feature feature,

                                            FeatureStore featureStore) {

    // TODO Auto-generated method stub

  }

  public void deleteGeometryFromFeatureStore(Geometry geometry,

                                             FeatureStore featureStore) {

    // TODO Auto-generated method stub

  }

  public void updateFeatureInFeatureStore(Feature feature,

                                          FeatureStore featureStore) {

    // TODO Auto-generated method stub

  }

  public void updateGeometryInFeatureStore(Geometry geometry,

                                           FeatureStore featureStore) {

    // TODO Auto-generated method stub

  }

  public Circle createCircle(Point2D p1, Point2D p2, FeatureStore featureStore)

      throws CreateGeometryException, DataException {

    Point centro = createPoint(p1.getX(), p1.getY(), featureStore);

    Point radio = createPoint(p2.getX(), p2.getY(), featureStore);

    return createCircle(centro, radio, featureStore);

  }

  public Circle createCircle(Point p1, Point p2, FeatureStore featureStore)

      throws CreateGeometryException, DataException {

    Circle circle = null;

    GeometryType featStoreGeomType = getGeomType(featureStore);

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

        featStoreGeomType.getSubType());

    circle.setPoints(p1, p2);

    return circle;

  }

  public Circle createCircle(Point center, double radius,

                             FeatureStore featureStore)

      throws CreateGeometryException, DataException {

    Circle circle = null;

    GeometryType featStoreGeomType = getGeomType(featureStore);

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

        featStoreGeomType.getSubType());

    circle.setPoints(center, radius);

    return circle;

  }

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

                       double angleExt, FeatureStore featureStore)

      throws CreateGeometryException, DataException {

    Arc arc = null;

    GeometryType featStoreGeomType = getGeomType(featureStore);

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

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

    return arc;

  }

  public Arc createArc(Point p1, Point midPoint, Point p2,

                       FeatureStore featureStore)

      throws CreateGeometryException, DataException,

      GeometryOperationNotSupportedException, GeometryOperationException {

    Arc arc = null;

    GeometryType featStoreGeomType = getGeomType(featureStore);

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

    arc.setPoints(p1, midPoint, p2);

    return arc;

  }

  public Point createPoint(double x, double y, FeatureStore featureStore)

      throws CreateGeometryException, DataException {

    Point point = null;

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

    point.setX(x);

    point.setY(y);

    return point;

  }

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

                          FeatureStore featureStore)

      throws CreateGeometryException, DataException {

    Curve line = null;

    line = (Curve) geomManager.create(TYPES.CURVE, getSubType(featureStore));

    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.GEOM3D; // ???????

  }

  public GeometryType getGeomType(FeatureStore featureStore)

      throws DataException {

    return featureStore.getDefaultFeatureType().getDefaultGeometryAttribute()

        .getGeomType();

  }

import org.gvsig.vectorediting.lib.prov.polyline.PolylineEditingProviderFactory;

    manager.addProviderFactory(new PolylineEditingProviderFactory());

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>

				org.gvsig.vectorediting.lib.prov.polyline

			</artifactId>

		</dependency>

/*

 * Copyright 2014 DiSiD Technologies S.L.L. All rights reserved.

 * 

 * Project  : DiSiD org.gvsig.vectorediting.lib.prov.polyline 

 * SVN Id   : $Id$

 */

package org.gvsig.vectorediting.lib.prov.polyline;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObject;

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

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

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

import org.gvsig.vectorediting.lib.api.EditingServiceInfo;

import org.gvsig.vectorediting.lib.api.EditingServiceParameter;

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

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

public class PolylineEditingProviderFactory extends AbstractProviderFactory  implements EditingProviderFactory {

  public final static String PROVIDER_NAME = "layer-polyline";

  public final static String PROVIDER_DESCRIPTION = "Inserts a polyline on the view";

  public static final String PROVIDER_NAME_PARAMS = "PolylineParams";

  public static final String PROVIDER_NAME_PARAMS_DESCRIPTION = "";

  private DynClass dynclass;

  public String getName() {

    return PROVIDER_NAME;

  }

  public DynObject createParameters() {

    DynObject dynobject = ToolsLocator.getDynObjectManager().createDynObject(

        dynclass);

    dynobject.setDynValue(PROVIDER_NAME_FIELD, PROVIDER_NAME);

    return dynobject;

  }

  public void initialize() {

    dynclass = ToolsLocator.getDynObjectManager().createDynClass(

        PROVIDER_NAME_PARAMS, PROVIDER_NAME_PARAMS_DESCRIPTION);

    dynclass.addDynFieldString(PROVIDER_NAME_FIELD);

    dynclass.addDynFieldObject(FEATURE_STORE_FIELD);

  }

  public EditingServiceInfo getServiceInfo() {

    EditingServiceInfo serviceInfo = new DefaultEditingServiceinfo(

        PROVIDER_NAME,

          "",

          true,

          null,

          null,

          new int[]{

            Geometry.TYPES.SURFACE,

            Geometry.TYPES.MULTISURFACE,

            Geometry.TYPES.CURVE,

            Geometry.TYPES.MULTICURVE});

      return serviceInfo;

  }

  public EditingServiceParameter getServiceParameterInfo() {

    // TODO Auto-generated method stub

    return null;

  }

  @Override

  protected Provider doCreate(DynObject parameters, ProviderServices services) {

    return new PolylineEditingProvider(services, parameters);

  }

  @Override

  protected DynClass createParametersDynClass() {

    // TODO Auto-generated method stub

    return null;

  }

}

/*

 * Copyright 2014 DiSiD Technologies S.L.L. All rights reserved.

 * 

 * Project  : DiSiD org.gvsig.vectorediting.lib.prov.polyline 

 * SVN Id   : $Id$

 */

package org.gvsig.vectorediting.lib.prov.polyline;

import java.util.ArrayList;

import java.util.List;

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

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

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

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

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

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

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

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.exception.BaseException;

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

import org.gvsig.vectorediting.lib.api.DrawingStatus;

import org.gvsig.vectorediting.lib.api.EditingServiceParameter;

import org.gvsig.vectorediting.lib.api.EditingServiceParameter.TYPE;

import org.gvsig.vectorediting.lib.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.EditingProviderServices;

public class PolylineEditingProvider extends AbstractEditingProvider implements

    EditingProvider {

  protected GeometryManager geomManager = GeometryLocator.getGeometryManager();

  private EditingProviderServices editingProviderServices = (EditingProviderServices) getProviderServices();

  private EditingServiceParameter points = new DefaultEditingServiceParameter(

      "Polyline", "Inserts a new point.", TYPE.LIST_POSITIONS, TYPE.OPTION);

  private boolean arcMode = false;

  private List<MyPolyLinePoint> values;

  private FeatureStore featureStore;

  public PolylineEditingProvider(ProviderServices providerServices,

      DynObject parameters) {

    super(providerServices);

    this.featureStore = (FeatureStore) parameters

        .getDynValue(EditingProviderFactory.FEATURE_STORE_FIELD);

  }

  /**

   * 

   * @param angle1

   * @param angle2

   * @return

   */

  private static double angleDistance(double angle1, double angle2) {

    if (angle1 < angle2) {

      return angle2 - angle1;

    }

    else {

      return ((Math.PI * 2) - angle1) + angle2;

    }

  }

  /**

   * 

   * @param lastPosition

   * @return

   * @throws BaseException

   */

  private DrawingStatus calculatePolyline(Point lastPosition)

      throws BaseException {

    DrawingStatus geometries = new DefaultDrawingStatus();

    Double antm = null;

    Double antb = null;

    Double m = null;

    Double b = null;

    boolean right = false;

    boolean addGeom = false;

    if (!values.isEmpty()) {

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

        }

        if (polyLinePoint.isArcMode()) {

          Curve lineAntPointToPoint = editingProviderServices.createLine(

              point.getX(), point.getY(), nextPoint.getX(), nextPoint.getY(),

              featureStore);

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

          m = lineParams[0];

          b = lineParams[1];

          Point[] pointPerpendicular = getPerpendicular(antm, antb, point,

              featureStore);

          Line linePointPerpendicular = geomManager

              .createLine(editingProviderServices.getSubType(featureStore));

          linePointPerpendicular.setPoints(pointPerpendicular[0],

              pointPerpendicular[1]);

          Point[] bisector = getPerpendicular(m, b,

              getMidPoint(point, nextPoint, featureStore), featureStore);

          Line lineBisector = geomManager.createLine(editingProviderServices

              .getSubType(featureStore));

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

          Point center = getIntersection(bisector, pointPerpendicular,

              featureStore);

          double startAngle = getAngle(center, point);

          double endAngle = getAngle(center, nextPoint);

          double radius = center.distance(point);

          double angleExt = 0.0;

          if (right) {

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

              if (m >= antm) {

                angleExt = angleDistance(endAngle, startAngle);

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

              }

              else {

                angleExt = -angleDistance(startAngle, endAngle);

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

              }

            }

            else {

              if (m >= antm) {

                angleExt = -angleDistance(startAngle, endAngle);

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

              }

              else {

                angleExt = angleDistance(endAngle, startAngle);

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

              }

            }

          }

          else {

            if (nextPoint.getX() < point.getX()) {

              if (m >= antm) {

                angleExt = angleDistance(endAngle, startAngle);

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

              }

              else {

                angleExt = -angleDistance(startAngle, endAngle);

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

              }

            }

            else {

              if (m >= antm) {

                angleExt = -angleDistance(startAngle, endAngle);

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

              }

              else {

                angleExt = angleDistance(endAngle, startAngle);

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

              }

            }

          }

          Arc arco = editingProviderServices.createArc(center, radius,

              startAngle, angleExt, featureStore);

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

            geometries.addGeometry(lineAntPointToPoint);

            geometries.addGeometry(center);

          }

          geometries.addGeometry(arco);

        }

        else {

          Curve geometry = editingProviderServices.createLine(point.getX(),

              point.getY(), nextPoint.getX(), nextPoint.getY(), featureStore);

          geometries.addGeometry(geometry);

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

          antm = antLineParams[0];

          antb = antLineParams[1];

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

        }

      }

      return geometries;

    }

    else {

      // TODO throw exception to be catch by editingBehavior to and error at

      // console.

    }

    return null;

  }

  /**

   * 

   * @param surface

   * @return

   */

  private Surface closeSurfaceIfNecessary(Surface surface) {

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

      Point firstp = surface.getVertex(0);

      firstp = (Point) firstp.cloneGeometry();

      surface.addVertex(firstp);

    }

    return surface;

  }

  public DrawingStatus draw(Point mousePosition) throws BaseException {

    return calculatePolyline(mousePosition);

  }

  public void finish() throws BaseException, DataException {

    GeometryType storeGeomType = editingProviderServices

        .getGeomType(featureStore);

    DrawingStatus finalGeometries = calculatePolyline(null);

    if (storeGeomType.isTypeOf(SURFACE)) {

      Surface surface = geomManager.createPolygon(storeGeomType.getSubType());

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

        surface.addVertex((Point) geometry);

      }

      surface = closeSurfaceIfNecessary(surface);

      editingProviderServices.insertGeometryIntoFeatureStore(surface,

          featureStore);

    }

    else if (storeGeomType.isTypeOf(CURVE)) {

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

        editingProviderServices.insertGeometryIntoFeatureStore(geometry,

            featureStore);

      }

    }

    else if (storeGeomType.isTypeOf(MULTISURFACE)) {

      MultiSurface multiSurface;

      multiSurface = geomManager.createMultiSurface(storeGeomType.getSubType());

      Surface surface = geomManager.createPolygon(storeGeomType.getSubType());

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

        if(geometry instanceof Curve){

          Curve curve = (Curve) geometry;

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

            surface.addVertex((Point) curve.getVertex(i));

          }

        }

      }

      surface = closeSurfaceIfNecessary(surface);

      multiSurface.addSurface(surface);

      editingProviderServices.insertGeometryIntoFeatureStore(multiSurface,

          featureStore);

    }

    else if (storeGeomType.isTypeOf(MULTICURVE)) {

      MultiCurve multiCurve;

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

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

        multiCurve.addCurve((Curve) geometry);

      }

      editingProviderServices.insertGeometryIntoFeatureStore(multiCurve,

          featureStore);

    }

  }

  /**

   * 

   * @param start

   * @param end

   * @return

   * @throws GeometryOperationNotSupportedException

   * @throws GeometryOperationException

   */

  private static 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;

  }

  /**

   * 

   * @param bisector

   * @param perpendicular

   * @param featureStore

   * @return

   * @throws CreateGeometryException

   * @throws DataException

   */

  private Point getIntersection(Point[] bisector, Point[] perpendicular,

                                FeatureStore featureStore)

      throws CreateGeometryException, DataException {

    Point p1 = bisector[0];

    Point p2 = bisector[1];

    Point p3 = perpendicular[0];

    Point p4 = perpendicular[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 editingProviderServices

          .createPoint(x, (m1 * x) + b1, featureStore);

    }

    else if (m1 == Double.POSITIVE_INFINITY) {

      double x = p1.getX();

      return editingProviderServices

          .createPoint(x, (m2 * x) + b2, featureStore);

    }

    else if (m2 == Double.POSITIVE_INFINITY) {

      double x = p3.getX();

      return editingProviderServices

          .createPoint(x, (m1 * x) + b1, featureStore);

    }

    return null;

  }

  /**

   * 

   * @param point

   * @param nextPoint

   * @return

   */

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

  }

  /**

   * 

   * @param p1

   * @param p2

   * @param featureStore

   * @return

   * @throws CreateGeometryException

   * @throws DataException

   */

  private Point getMidPoint(Point p1, Point p2, FeatureStore featureStore)

      throws CreateGeometryException, DataException {

    double x = (p1.getX() + p2.getX()) / 2;

    double y = (p1.getY() + p2.getY()) / 2;

    return editingProviderServices.createPoint(x, y, featureStore);

  }

  public String getName() {

    return PolylineEditingProviderFactory.PROVIDER_NAME;

  }

  /**

   * 

   * @param i

   * @return

   */

  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;

  }

  /**

   * 

   * @param m

   * @param b

   * @param perp

   * @param featureStore

   * @return

   * @throws CreateGeometryException

   * @throws DataException

   */

  private Point[] getPerpendicular(Double m, Double b, Point perp,

                                   FeatureStore featureStore)

      throws CreateGeometryException, DataException {

    if (m == Double.POSITIVE_INFINITY) {

      Point[] res = new Point[2];

      res[0] = editingProviderServices

          .createPoint(0, perp.getY(), featureStore);

      res[1] = editingProviderServices

          .createPoint(1, perp.getY(), featureStore);

      return res;

    }

    else if (m == Double.NEGATIVE_INFINITY) {

      Point[] res = new Point[2];

      res[0] = editingProviderServices

          .createPoint(1, perp.getY(), featureStore);

      res[1] = editingProviderServices

          .createPoint(0, perp.getY(), featureStore);

      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] = editingProviderServices.createPoint(perp.getX(), 0.0,

            featureStore);

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

            featureStore);

      }

      else {

        res[0] = editingProviderServices.createPoint(0, 0.0 + b1, featureStore);

        res[1] = editingProviderServices.createPoint(perp.getX(),

            (m1 * perp.getX()) + b1, featureStore);

      }

      return res;

    }

  }

  /**

   * 

   * @param surface

   * @return

   */

  private boolean isClose(Surface surface) {

    if(surface != null){

      Point firstPoint = surface.getVertex(0);

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

      if(firstPoint.equals(lastPoint)){

        return true;

      }

    }

    return false;

  }

  public EditingServiceParameter next() {

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

      if(arcMode){

        points.setDescription("Inserts [L] to change to line mode. Double-click to finish. Inserts new point.");

      }

      else{

        points.setDescription("Inserts [A] to change to arc mode. Double-click to finish. Inserts new point.");

      }

    }

    return points;

  }

  public void start() {

    values = new ArrayList<MyPolyLinePoint>();

  }

  public void stop() {

    // TODO Auto-generated method stub

  }

  /**

   * 

   * @param param

   * @param value

   */

  private void validateAndInsertValue(EditingServiceParameter param,

                                      Object value) {

    if (value instanceof String) {

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

        if (((String) value).equalsIgnoreCase("A")) {

          arcMode = true;

        }

        else if (((String) value).equalsIgnoreCase("L")) {

          arcMode = false;

        }

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

    }

  }

  public void value(Object value) {

    EditingServiceParameter param = next();

    validateAndInsertValue(param, value);

  }

}

/*

 * Copyright 2014 DiSiD Technologies S.L.L. All rights reserved.

 * 

 * Project  : DiSiD org.gvsig.vectorediting.lib.prov.polyline 

 * SVN Id   : $Id$

 */

package org.gvsig.vectorediting.lib.prov.polyline;

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

public class MyPolyLinePoint {

  private Point point;

  private boolean arcMode;

  public MyPolyLinePoint(Point point, boolean mode){

    this.point = point;

    this.arcMode = mode;

  }

  public Point getPoint() {

    return point;

  }

  public void setPoint(Point point) {

    this.point = point;

  }

  public boolean isArcMode() {

    return arcMode;

  }

  public void setArcMode(boolean arcMode) {

    this.arcMode = arcMode;

  }

}

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>

  <parent>

    <groupId>org.gvsig</groupId>

    <artifactId>org.gvsig.vectorediting.lib.prov</artifactId>

    <version>1.0.0-SNAPSHOT</version>

  </parent>

  <artifactId>org.gvsig.vectorediting.lib.prov.polyline</artifactId>

  <name>org.gvsig.vectorediting.lib.prov.polyline</name>

</project>

		<module>org.gvsig.vectorediting.lib.prov.polyline</module>

  /**

   * 

   */

  public void setDescription(String newDescription);

import org.gvsig.fmap.geom.GeometryException;

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

import org.gvsig.vectorediting.lib.api.DrawingStatus;

   * @throws CreateGeometryException

   * @throws BaseException

  public DrawingStatus draw(Point mousePosition) throws BaseException;

   * @throws CreateGeometryException

   * @throws DataException

   * @throws GeometryException

   * @throws GeometryOperationException

  public void finish() throws DataException, BaseException;

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

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

  public void insertFeatureIntoFeatureStore(Feature feature,

                                            FeatureStore featureStore);

  public void insertGeometryIntoFeatureStore(Geometry geometry,

                                             FeatureStore featureStore);

  public void deleteFeatureFromFeatureStore(Feature feature,

                                            FeatureStore featureStore);

  public void deleteGeometryFromFeatureStore(Geometry geometry,

                                             FeatureStore featureStore);

  public void updateFeatureInFeatureStore(Feature feature,

                                          FeatureStore featureStore);

  public void updateGeometryInFeatureStore(Geometry geometry,

                                           FeatureStore featureStore);

  /**

   * Create a circle from a GeneralPath. If there is an error return

   * <code>null</code> and add the error to the log

   *

   * @param p1

   * @param p2

   * @return The circle

   * @throws CreateGeometryException

   * @throws DataException

   */

  public Circle createCircle(Point2D p1, Point2D p2, FeatureStore featureStore)

      throws CreateGeometryException, DataException;

  /**

   * Create a circle. If there is an error return <code>null</code> and add the

   * error to the log

   *

   * @param p1

   * @param p2

   * @return The circle

   * @throws CreateGeometryException

   * @throws DataException

   */

  public Circle createCircle(Point p1, Point p2, FeatureStore featureStore)

      throws CreateGeometryException, DataException;

  /**

   * Create a circle. If there is an error return <code>null</code> and add the

   * error to the log

   *

   * @param center

   * @param radius

   * @return The circle

   * @throws CreateGeometryException

   * @throws DataException

   */

  public Circle createCircle(Point center, double radius,

                             FeatureStore featureStore)

      throws CreateGeometryException, DataException;

  /**

   * Create a circle. If there is an error return <code>null</code> and add the

   * error to the log

   *

   * @param center

   * @param radius

   * @param startAngle in radians

   * @param angleExt

   * @return The circle

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

   * @throws DataException

   */

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

                       double angleExt, FeatureStore featureStore)

      throws CreateGeometryException, DataException;