Application: gvSIG desktop » gvSIG tools: Vector editing

/*

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

import org.gvsig.tools.dynobject.DynObject;

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

import org.gvsig.vectorediting.lib.api.exceptions.StartServiceException;

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 I18nManager i18nManager = ToolsLocator.getI18nManager();

  private EditingServiceParameter points = new DefaultEditingServiceParameter(

      "Polyline", i18nManager.getTranslation("indicates_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 VectorEditingException

   */

  private DrawingStatus calculatePolyline(Point lastPosition)

      throws VectorEditingException {

    DrawingStatus geometries = new DefaultDrawingStatus();

    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;

    Curve lineAntPointToPoint = null;

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

          try {

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

            center = getIntersection(bisector, pointPerpendicular, featureStore);

            startAngle = getAngle(center, point);

            endAngle = getAngle(center, nextPoint);

            radius = center.distance(point);

          }

          catch (Exception e) {

            throw new DrawServiceException(e);

          }

          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 = null;

          try {

            arco = editingProviderServices.createArc(center, radius,

                startAngle, angleExt, featureStore);

          }

          catch (Exception e) {

            throw new DrawServiceException(e);

          }

          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 {

          try {

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

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

            geometries.addGeometry(geometry);

          }

          catch (Exception e) {

            throw new DrawServiceException(e);

          }

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

          antm = antLineParams[0];

          antb = antLineParams[1];

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

        }

      }

      return geometries;

    }

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

    try {

      return calculatePolyline(mousePosition);

    }

    catch (Exception e) {

      throw new DrawServiceException(e);

    }

  }

  public void finishAndStore() throws FinishServiceException {

    try {

      GeometryType storeGeomType = editingProviderServices

          .getGeomType(featureStore);

      Geometry geometry = finish();

      if (geometry == null) {

        if (storeGeomType.isTypeOf(CURVE)) {

          DrawingStatus finalGeometries = calculatePolyline(null);

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

            editingProviderServices.insertGeometryIntoFeatureStore(geom,

                featureStore);

          }

        }

        else if (storeGeomType.isTypeOf(MULTICURVE)) {

          DrawingStatus finalGeometries = calculatePolyline(null);

          MultiCurve multiCurve;

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

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

            multiCurve.addCurve((Curve) geom);

          }

          editingProviderServices.insertGeometryIntoFeatureStore(multiCurve,

              featureStore);

        }

      }

      else {

        editingProviderServices.insertGeometryIntoFeatureStore(geometry,

            featureStore);

      }

    }

    catch (Exception e) {

      throw new FinishServiceException(e);

    }

  }

  public Geometry finish() throws FinishServiceException {

    try {

      GeometryType storeGeomType = editingProviderServices

          .getGeomType(featureStore);

      if (storeGeomType.isTypeOf(SURFACE)) {

        DrawingStatus finalGeometries = calculatePolyline(null);

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

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

          surface.addVertex((Point) geometry);

        }

        surface = closeSurfaceIfNecessary(surface);

        return (Geometry) surface;

      }

      else if (storeGeomType.isTypeOf(MULTISURFACE)) {

        DrawingStatus finalGeometries = calculatePolyline(null);

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

        return (Geometry) multiSurface;

      }

      return null;

    }

    catch (Exception e) {

      throw new FinishServiceException(e);

    }

  }

  /**

   * @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(i18nManager

                .getTranslation("inserts_L_to_change_to_line_mode_double_click_to_finish_indate_new_point"));

      }

      else {

        points

            .setDescription(i18nManager

                .getTranslation("inserts_A_to_change_to_arc_mode_double_click_to_finish_indate_new_point"));

      }

    }

    return points;

  }

  public void start() throws StartServiceException {

    stop();

    values = new ArrayList<MyPolyLinePoint>();

  }

  public void stop() {

    if (values != null) {

      values.clear();

    }

    points.setDescription(i18nManager.getTranslation("indicates_new_point"));

    arcMode = false;

  }

  /**

   * @param param

   * @param value

   */

  private void validateAndInsertValue(EditingServiceParameter param,

                                      Object value)

      throws InvalidEntryException {

    if (value instanceof String) {

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

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

            || ((String) value).equalsIgnoreCase("L")) {

          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 {

          throw new InvalidEntryException(null);

        }

      }

      else {

        throw new InvalidEntryException(null);

      }

    }

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

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

    }

  }

  public void value(Object value) throws InvalidEntryException {

    EditingServiceParameter param = next();

    validateAndInsertValue(param, value);

  }

}