Application: gvSIG desktop » gvSIG tools: Vector editing

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2015 gvSIG Association

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.vectorediting.lib.prov.extendline.operation;

import java.util.HashMap;

import java.util.Map;

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

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

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

import org.gvsig.fmap.geom.Geometry;

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

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

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

import org.gvsig.tools.dispose.DisposableIterator;

/**

 * @author llmarques

 *

 */

public class ExtendLineOperationUtils {

    /**

     * Use it to indicate start side should be extended

     */

    public static final String START_SIDE = "start";

    /**

     * Use it to indicate end side should be extended

     */

    public static final String END_SIDE = "end";

    /**

     * Number of projections computed to know intersection points.

     */

    private final static int PROJECTION_LIMIT = 100;

    private static Map<Integer, ExtendLineOperation> operations =

        new HashMap<Integer, ExtendLineOperation>();

    public ExtendLineOperationUtils() {

    }

    public static void register(ExtendLineOperation operation, int geometryType) {

        operations.put(geometryType, operation);

    }

    public static ExtendLineOperation getOperation(Primitive geom) {

        Integer type = geom.getGeometryType().getType();

        ExtendLineOperation operation = operations.get(type);

        return operation;

    }

    /**

     * Calculates the nearest intersection among curve and boundary objects

     * depending on side received as parameter.

     * 

     * @param line

     *            to be extended

     * @param sideToExtend

     *            What side will be extend. Use

     *            {@link ExtendLineOperationUtils#START_SIDE} and

     *            {@link ExtendLineOperationUtils#END_SIDE}

     * @param boundaryObjects

     *            to calculate intersection points.

     * @return the nearest intersection point. Return Null if arc does not

     *         intersect

     *         with any boundary object

     */

    public static Point curveIntersection(Curve line, String sideToExtend,

        FeatureSelection boundaryObjects) throws CreateGeometryException,

        DataException, GeometryOperationNotSupportedException,

        GeometryOperationException {

        Point initPoint = null;

        Point endPoint = null;

        // Start side line is formed by second point and first point

        if (sideToExtend.equalsIgnoreCase(START_SIDE)) {

            initPoint = line.getVertex(1);

            endPoint = line.getVertex(0);

            // End side line is formed by penultimate point and last point

        } else if (sideToExtend.equalsIgnoreCase(END_SIDE)) {

            initPoint = line.getVertex(line.getNumVertices() - 2);

            endPoint = line.getVertex(line.getNumVertices() - 1);

        }

        return getIntersectionOfProjectedLine(initPoint, endPoint,

            boundaryObjects);

    }

    /**

     * Calculates the nearest intersection point among arc and boundary objects

     * depending on side received as parameter.

     * 

     * Strategy:

     * 

     * 1- Create a full arc with the same center and radius of arc received by

     * parameter.

     * 2- Iterate over boundary objects.

     * 3- If some boundary object intersects with full arc, calculates the

     * distance to start point or end point depending on side to be extend.

     * 4- Return the nearest intersection point.

     * 

     * @param arcToBeExtended

     *            Arc to be extended

     * @param sideToExtend

     *            What side will be extend. Use

     *            {@link ExtendLineOperationUtils#START_SIDE} and

     *            {@link ExtendLineOperationUtils#END_SIDE}

     * @param boundaryObjects

     *            to calculate intersection points.

     * @return the nearest intersection point. Return Null if arc does not

     *         intersect with any boundary object

     */

    public static Point arcIntersection(Arc arcToBeExtended,

        String sideToExtend, FeatureSelection boundaryObjects)

        throws GeometryOperationNotSupportedException,

        GeometryOperationException, CreateGeometryException, DataException {

        GeometryManager geoManager = GeometryLocator.getGeometryManager();

        int subtype = arcToBeExtended.getGeometryType().getSubType();

        Point center = arcToBeExtended.getCenterPoint();

        double radius = center.distance(arcToBeExtended.getInitPoint());

        Point intersection = null;

        double minDistance = Double.POSITIVE_INFINITY;

        Arc tmpArc = (Arc) geoManager.create(TYPES.ARC, subtype);

        tmpArc.setPoints(center, radius, 0, Math.PI * 2);

        DisposableIterator it = boundaryObjects.fastIterator();

        while (it.hasNext()) {

            Feature feature = (Feature) it.next();

            Geometry geometry = feature.getDefaultGeometry();

            if (tmpArc.intersects(geometry)) {

                Geometry intersectionGeometry = tmpArc.intersection(geometry);

                if (intersectionGeometry instanceof MultiPoint) {

                    MultiPoint intersectionMultiPoint =

                        (MultiPoint) intersectionGeometry;

                    for (int i = 0; i < intersectionMultiPoint

                        .getPrimitivesNumber(); i++) {

                        Point point = intersectionMultiPoint.getPointAt(i);

                        double distance = Double.POSITIVE_INFINITY;

                        if (sideToExtend.equalsIgnoreCase(START_SIDE)) {

                            distance =

                                point.distance(arcToBeExtended.getInitPoint());

                        } else if (sideToExtend.equalsIgnoreCase(END_SIDE)) {

                            distance =

                                point.distance(arcToBeExtended.getEndPoint());

                        }

                        if (distance < minDistance) {

                            intersection = point;

                            minDistance = distance;

                        }

                    }

                } else if (intersectionGeometry instanceof Point) {

                    Point intersectionPoint = (Point) intersectionGeometry;

                    double distance = Double.POSITIVE_INFINITY;

                    if (sideToExtend.equalsIgnoreCase("start")) {

                        distance =

                            intersectionPoint.distance(arcToBeExtended

                                .getInitPoint());

                    } else if (sideToExtend.equalsIgnoreCase("end")) {

                        distance =

                            intersectionPoint.distance(arcToBeExtended

                                .getEndPoint());

                    }

                    if (distance < minDistance) {

                        intersection = intersectionPoint;

                        minDistance = distance;

                    }

                }

            }

        }

        it.dispose();

        return intersection;

    }

    // FIXME: remove this method when geometry library has this utility method

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

    }

    /**

     * Gets intersection among the line formed by initPoint and endPoint and

     * boundary objects. If line or its projection does not intersect with any

     * boundary object return null.

     * 

     * Strategy:

     * 

     * 1- Get module of line to determine if an intersection point already be

     * vertex of line. If the distance between intersection point and start

     * point of line is less than module indicates that intersection point

     * already be curve point.

     * 2- Project line with the line parametric equation.

     * 3- Iterate over boundary objects.

     * 4- Check if boundary object does not contains end point of projected

     * line.

     * 5- If projected line intersects with any boundary object, get the nearest

     * intersection point

     * 6- Return it.

     * 

     * 

     * @param initPoint

     *            of curve to extend

     * @param endPoint

     *            end point of curve to extend

     * @param boundaryObjects

     *            to calculate intersection points.

     * @return the nearest intersection point. Return Null if arc does not

     *         intersect with any boundary object

     */

    public static Point getIntersectionOfProjectedLine(Point initPoint,

        Point endPoint, FeatureSelection boundaryObjects)

        throws GeometryOperationNotSupportedException,

        GeometryOperationException, DataException, CreateGeometryException {

        GeometryManager geoManager = GeometryLocator.getGeometryManager();

        int subtype = initPoint.getGeometryType().getSubType();

        double module = initPoint.distance(endPoint);

        double minDistance = Double.POSITIVE_INFINITY;

        Point intersectionPoint = null;

        double x, y;

        double x1 = initPoint.getX();

        double y1 = initPoint.getY();

        double x2 = endPoint.getX();

        double y2 = endPoint.getY();

        for (int t = 1; t < PROJECTION_LIMIT; t += 10) {

            x = (x2 - x1) * t + x1;

            y = (y2 - y1) * t + y1;

            DisposableIterator it = boundaryObjects.fastIterator();

            while (it.hasNext()) {

                Feature feature = (Feature) it.next();

                Geometry geometry = feature.getDefaultGeometry();

                Point projectedPoint = geoManager.createPoint(x, y, subtype);

                if (!geometry.contains(projectedPoint)) {

                    Curve tmpLine = geoManager.createLine(subtype);

                    tmpLine.setPoints(initPoint, projectedPoint);

                    if (tmpLine.intersects(geometry)) {

                        Geometry intersecionGeometry =

                            geometry.intersection(tmpLine);

                        if (intersecionGeometry instanceof Point) {

                            double distance =

                                ((Point) intersecionGeometry)

                                    .distance(initPoint);

                            if (distance < minDistance && distance > module) {

                                intersectionPoint = (Point) intersecionGeometry;

                                minDistance = distance;

                            }

                        } else if (intersecionGeometry instanceof MultiPoint) {

                            MultiPoint intersectionMultiPoint =

                                (MultiPoint) intersecionGeometry;

                            for (int i = 0; i < intersectionMultiPoint

                                .getPrimitivesNumber(); i++) {

                                double distance =

                                    intersectionMultiPoint.getPointAt(i)

                                        .distance(initPoint);

                                if (distance < minDistance && distance > module) {

                                    intersectionPoint =

                                        intersectionMultiPoint.getPointAt(i);

                                    minDistance = distance;

                                }

                            }

                        } else if (intersecionGeometry instanceof Curve) {

                            Curve intersectionCurve =

                                (Curve) intersecionGeometry;

                            for (int i = 0; i < intersectionCurve

                                .getNumVertices(); i++) {

                                double distance =

                                    intersectionCurve.getVertex(i).distance(

                                        initPoint);

                                if (distance < minDistance && distance > module) {

                                    intersectionPoint =

                                        intersectionCurve.getVertex(i);

                                    minDistance = distance;

                                }

                            }

                        }

                    }

                }

            }

            it.dispose();

            if (intersectionPoint != null) {

                break;

            }

        }

        return intersectionPoint;

    }

}