Application: gvSIG desktop » gvSIG tools: Vector editing

geometry_to_extend_to=Geometr\u00eda hasta la que extender

geometry_to_trim_with=Geometr\u00eda con la que recortar

shearing_point=Punto de recorte

geometry_to_extend_to= Geometry to extend to

geometry_to_trim_with=Geometry to trim with

shearing_point=Shearing point

import org.gvsig.fmap.geom.Geometry;

     * Trim line, taking as cutting edges the shears received as

     * parameters.Inserted point is the point inserted by user.It is used to determinate

 what segment of curve it must trimmed.If curveToBeExtended does not intersect with any geometry, the geometry

 will not be modified.

     * 

     * 

     * @param curveToTrim

     *            Curve to trim

     * @param shearingPoint

     *            Point inserted by user to determinate what side of curve must

     *            be extended.

     * @param shears

     *            If curveToBeExtended intersects with some shears, it will

     *            be cutted to it. If there are several shears that

     *            intersects with curveToTrim, it will be cutted to

     *            nearest point.

     * @return Trimmed line

     * @throws org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException

     * @throws org.gvsig.fmap.geom.operation.GeometryOperationException

     * @throws org.gvsig.fmap.dal.exception.DataException

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

     */

    public MultiCurve trimLine(Curve curveToTrim, Point shearingPoint,

        FeatureSelection shears)

        throws GeometryOperationNotSupportedException,

        GeometryOperationException, DataException, CreateGeometryException,

        LocatorException;

        /**

     * parameters.Inserted point is the point inserted by user.It is used to determinate

 what segment of curve it must trimmed.If curveToBeExtended does not intersect with any geometry, the geometry

 will not be modified.

     * @param shearingPoint

     * @param shears

     * @throws org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException

     * @throws org.gvsig.fmap.geom.operation.GeometryOperationException

     * @throws org.gvsig.fmap.dal.exception.DataException

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

    public MultiCurve trimLine(Curve curveToTrim, Point shearingPoint,

        Geometry shears)

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.GeometryUtils;

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

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

    public static final double SNAP_TOLERANCE = 0.1;

        double startAngle = GeometryUtils.calculateAngle(center, initPoint);

        double endAngle = GeometryUtils.calculateAngle(center, endPoint);

    public static Double getSide(Geometry geometry, Point point) throws GeometryOperationNotSupportedException, GeometryOperationException, CreateGeometryException{

        GeometryManager geomManager= GeometryLocator.getGeometryManager();

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

        Geometry[] closestPoints = geometry.closestPoints(point);

        if(geometry instanceof Line) {

            Line line = (Line)geometry;

            int index = 0;

            Point previousVertex = null;

            for (Point vertex : line) {

                if(index < line.getNumVertices()-1){

                    Point nextVertex = line.getVertex(index+1);

                    Line segment = geomManager.createLine(subtype);

                    segment.addVertex(vertex);

                    segment.addVertex(nextVertex);

                    Geometry p = closestPoints[0];

                    double coef = TrimLineOperationUtils.getSide(vertex, nextVertex, point);

                    if(segment.isWithinDistance(p, SNAP_TOLERANCE)) {

                        if(vertex.isWithinDistance(p, SNAP_TOLERANCE) && previousVertex != null){

                            double previousCoef = TrimLineOperationUtils.getSide(previousVertex, vertex, point);

                            if(previousCoef == coef){

                                return coef;

                            } else {

                                return Double.NaN;

                            }

                        } else if(nextVertex.isWithinDistance(p, SNAP_TOLERANCE) && index < line.getNumVertices()-2){

                            Point nextNextVertex = line.getVertex(index+2);

                            double nextCoef = TrimLineOperationUtils.getSide(nextVertex, nextNextVertex, point);

                            if(nextCoef == coef){

                                return coef;

                            } else {

                                return Double.NaN;

                            }

                        }

                        return coef;

                    }

                    previousVertex = vertex;

                }

                index++;

            }

        } else if (geometry instanceof MultiLine) {

            double minDistance = Double.POSITIVE_INFINITY;

            MultiLine multiline = (MultiLine)geometry;

            Geometry nearestComponent = null;

            for (Geometry component : multiline) {

                double distance = component.distance(point);

                if(distance < minDistance){

                    nearestComponent = component;

                    minDistance = distance;

                }

            }

            if(nearestComponent != null) {

                return TrimLineOperationUtils.getSide(nearestComponent, point);

            }

        }

        return Double.NaN;

    }

    public static double getSide(Point a, Point b, Point c) {

        if (a == null || b == null || c == null || a.equals(b) || a.equals(c) || b.equals(c)) {

            throw new IllegalArgumentException("Points must be different and not null.");

        }

        return Math.signum((b.getX() - a.getX()) * (c.getY() - a.getY()) - (b.getY() - a.getY()) * (c.getX() - a.getX()));

    }

    public static Double getSide(Geometry geometry, Curve curve) throws GeometryOperationNotSupportedException, GeometryOperationException, CreateGeometryException {

        GeometryManager geomManager= GeometryLocator.getGeometryManager();

        Double segmentSide = Double.NaN;

        if (curve.getNumVertices() == 1) {

            //

            segmentSide = TrimLineOperationUtils.getSide(geometry, curve.getVertex(0));

        } if (curve.getNumVertices() == 2) {

            int steps = 100;

            //We skip the first and last points because 

            //they can coincide with the geometry and give wrong results

            for(int t=1; t<steps; t++){

                double xLen = curve.getVertex(1).getX() - curve.getVertex(0).getX();

                double yLen = curve.getVertex(1).getY() - curve.getVertex(0).getY();

                double diffX = xLen/steps;

                double diffY = yLen/steps;

                Point anyPoint = geomManager.createPoint(

                        curve.getVertex(0).getX() + t*diffX,

                        curve.getVertex(0).getY() + t*diffY,

                        geometry.getGeometryType().getSubType());

                segmentSide = TrimLineOperationUtils.getSide(geometry, anyPoint);

                if (!segmentSide.isNaN()) {

                    break;

                }

            }

        } else {

            //We skip the first and last points because 

            //they can coincide with the geometry and give wrong results

            for (int j = 1; j < curve.getNumVertices()-1; j++) {

                Point anyPoint = curve.getVertex(j);

                segmentSide = TrimLineOperationUtils.getSide(geometry, anyPoint);

                if (!segmentSide.isNaN()) {

                    break;

                }

            }

        }

        return segmentSide;

    }

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

    private static final Logger LOGGER = LoggerFactory

        .getLogger(CurveTrimLineOperation.class);

     * 1. Get arc segments between curve and shears.

    public MultiCurve trimLine(Curve curveToTrim, Point shearingPoint,

        FeatureSelection shears)

        DisposableIterator it = shears.fastIterator();

            double distance = curve.distance(shearingPoint);

        Geometry snapTo = curve.snapTo(splitter, TrimLineOperationUtils.SNAP_TOLERANCE);

    /*

     * Strategy:

     * 

     * 1. Get line segments between curve and shears

     * 2. Determinate what segment of curve must be deleted

     * 3. Rebuild curve taking into account the segment that must be deleted

     */

    @Override

    public MultiCurve trimLine(Curve curveToTrim, Point shearingPoint,

        Geometry shears)

        throws GeometryOperationNotSupportedException,

        GeometryOperationException, DataException, CreateGeometryException,

        LocatorException {

        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

        int subType = curveToTrim.getGeometryType().getSubType();

        MultiCurve segmentedLine = geometryManager.createMultiCurve(subType);

        segmentedLine.addCurve(curveToTrim);

        Geometry tmpDifference = segmentedLine.difference(shears);

        if (tmpDifference instanceof MultiCurve) {

            segmentedLine = (MultiCurve) tmpDifference;

        } else if(tmpDifference instanceof Curve) {

            // Sometimes line to split and splitter are so close ( distance

            // between geometries < 0.00000000001 ). In this cases, we try

            // to do an enhance difference.

            // If the result is instance of Curve, it is considered that

            // lines don't intersect.

            // If the result is instance of Multicurve, lines are so close

            // and it is considered that lines intersect.

            Geometry enchancedGeometry = enhancedDifference(shears, (Curve) tmpDifference);

            if(enchancedGeometry instanceof MultiCurve){

                segmentedLine = (MultiCurve) enchancedGeometry;

            } 

        }

        if (segmentedLine.getPrimitivesNumber() == 1) {

            return segmentedLine;

        }

        double side = TrimLineOperationUtils.getSide(shears, shearingPoint);

        int index = -1;

        if(!Double.isNaN(side)){

            Curve curve;

            double minDistance = Double.POSITIVE_INFINITY;

            for (int i = 0; i < segmentedLine.getPrimitivesNumber(); i++) {

                curve = segmentedLine.getCurveAt(i);

                double distance = curve.distance(shearingPoint);

                if (distance < minDistance) {

                    Double segmentSide = TrimLineOperationUtils.getSide(shears, curve);

                    if(segmentSide == side){

                        index = i;

                        minDistance = distance;

                    }

                }

            }

        }

        MultiCurve trimmedCurve = geometryManager.createMultiCurve(subType);

        Curve tmpCurve = null;

        for (int i = 0; i < segmentedLine.getPrimitivesNumber(); i++) {

            if (i == index) {

                if (tmpCurve != null) {

                    trimmedCurve.addCurve(tmpCurve);

                    tmpCurve = null;

                }

                continue;

            }

            if (tmpCurve != null) {

                tmpCurve = union(tmpCurve, segmentedLine.getCurveAt(i));

            } else {

                tmpCurve = segmentedLine.getCurveAt(i);

            }

        }

        if (tmpCurve != null) {

            trimmedCurve.addCurve(tmpCurve);

        }

        return trimmedCurve;

    }

    public MultiCurve trimLine(Curve curveToTrim, Point shearsPoint,

        FeatureSelection shearingObjects)

        DisposableIterator it = shearingObjects.fastIterator();

            double distance = arc.distance(shearsPoint);

        Arc arc1 = null;

        if(curveA instanceof Arc){

            arc1 = (Arc)curveA;

        } else {

            arc1 =

        }

        Arc arc2 = null;

        if(curveB instanceof Arc){

            arc2 = (Arc)curveB;

        } else {

            arc2 = TrimLineOperationUtils.createArc(center, radius,

        }

    /*

     * Strategy:

     * 

     * 1. Get arc segments between arc and boundary objects.

     * 2. Determinate what segment of arc must be deleted

     * 3. Rebuild arc taking into account the segment that must be deleted

     */

    @Override

    public MultiCurve trimLine(Curve curveToTrim, Point shearingPoint,

        Geometry boundaryObject)

        throws GeometryOperationNotSupportedException,

        GeometryOperationException, DataException, CreateGeometryException,

        LocatorException {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        Arc arcToTrim = (Arc) curveToTrim;

        if(!arcToTrim.isCCW()) {

            Arc tmpArcToTrim = (Arc)geomManager.create(arcToTrim.getGeometryType());

            tmpArcToTrim.setPoints(arcToTrim.getEndPoint(), arcToTrim.getMiddlePoint(), arcToTrim.getInitPoint());

            arcToTrim = tmpArcToTrim;

        }

        GeometryManager geoManager = GeometryLocator.getGeometryManager();

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

        MultiCurve segmentedArc = geoManager.createMultiCurve(subtype);

        segmentedArc.addCurve(arcToTrim);

        Geometry geometry = boundaryObject;

        Geometry tmpDifference = segmentedArc.difference(geometry);

        if (tmpDifference instanceof MultiCurve) {

            segmentedArc = (MultiCurve) tmpDifference;

        }

        double side = TrimLineOperationUtils.getSide(boundaryObject, shearingPoint);

        int index = -1;

        if(!Double.isNaN(side)){

            Curve curve;

            double minDistance = Double.POSITIVE_INFINITY;

            for (int i = 0; i < segmentedArc.getPrimitivesNumber(); i++) {

                curve = segmentedArc.getCurveAt(i);

                double distance = curve.distance(shearingPoint);

                if (distance < minDistance) {

                    Double segmentSide = TrimLineOperationUtils.getSide(boundaryObject, curve);

                    if(segmentSide == side){

                        index = i;

                        minDistance = distance;

                    }

                }

            }

        }

        MultiCurve trimmedArc = geoManager.createMultiCurve(subtype);

        Point center = arcToTrim.getCenterPoint();

        // If Arc#getCenter() return null, we will have to use this "trick" to

        // get arc center.

        if (center == null) {

            center =

                geoManager.createPoint(arcToTrim.getEnvelope().getCenter(0),

                    arcToTrim.getEnvelope().getCenter(1), subtype);

        }

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

        Curve tmpCurve = null;

        for (int i = 0; i < segmentedArc.getPrimitivesNumber(); i++) {

            if (i == index) {

                if (tmpCurve != null) {

                    trimmedArc.addCurve(tmpCurve);

                    tmpCurve = null;

                }

                continue;

            }

            if (tmpCurve != null) {

                tmpCurve =

                    union(center, radius, tmpCurve, segmentedArc.getCurveAt(i));

            } else {

                tmpCurve = segmentedArc.getCurveAt(i);

            }

        }

        if (tmpCurve != null) {

            trimmedArc.addCurve(tmpCurve);

        }

        return trimmedArc;

    }

import java.util.HashMap;

import java.util.Map;

import java.util.logging.Level;

import java.util.logging.Logger;

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

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

import org.gvsig.fmap.geom.GeometryException;

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

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

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

    private final EditingServiceParameter geometryToTrimWithParameter;

    private final EditingServiceParameter shearingPointParameter;

    protected Map<EditingServiceParameter, Object> values;

        this.geometryToTrimWithParameter =

            new DefaultEditingServiceParameter("geometry_to_trim_with", "geometry_to_trim_with",

        this.shearingPointParameter

                = new DefaultEditingServiceParameter("shearing_point",

                        "shearing_point", TYPE.POSITION);

    @Override

        if (values.get(selectionParameter) == null) {

        } else if (values.get(geometryToTrimWithParameter) == null) {

            return geometryToTrimWithParameter;

        } else if (values.get(shearingPointParameter) == null) {

            return shearingPointParameter;

    @Override

        FeatureSelection selection = (FeatureSelection) values.get(selectionParameter);

        Geometry shears = (Geometry) values.get(geometryToTrimWithParameter);

        if (selection != null && shears != null) {

                DisposableIterator selectionIterator = null;

                selectionIterator = selection.fastIterator();

                while (selectionIterator.hasNext()) {

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

                    if (feature != null) {

                        if(geometry != null && geometry.intersects(shears)) {

                            if (geometry instanceof MultiCurve) {

                                MultiCurve multiCurve = (MultiCurve) geometry;

                                for (int i = 0; i < multiCurve

                                        .getPrimitivesNumber(); i++) {

                                    Curve curve = multiCurve.getCurveAt(i);

                                    MultiCurve trimmedCurve

                                            = trimLine(mousePosition, curve, shears);

                                    for (int j = 0; j < trimmedCurve

                                            .getPrimitivesNumber(); j++) {

                                        drawingStatus.addStatus(trimmedCurve.getCurveAt(j),

                                                lineSymbolEditing, "");

                                    }

                                }

                            } else if (geometry instanceof Curve) {

                                Curve curve = (Curve) geometry;

                                MultiCurve extendedCurve

                                        = trimLine(mousePosition, curve, shears);

                                        .getPrimitivesNumber(); j++) {

                                            extendedCurve.getCurveAt(j),

                                            lineSymbolEditing, "");

            } catch (BaseException ex) {

                throw new DrawServiceException(ex);

    private MultiCurve trimLine(Point shearingPoint, Curve curve, Geometry shearsGeometry)

        return operation.trimLine(curve, shearingPoint, shearsGeometry);

    @Override

        values.clear();

    @Override

        parameters.add(geometryToTrimWithParameter);

        parameters.add(shearingPointParameter);

    @Override

        if (parameter == selectionParameter) {

            if (value instanceof FeatureSelection) {

                FeatureSelection featureSelection = (FeatureSelection) value;

                if (featureSelection.getSelectedCount() > 0) {

                    try {

                        featureSelection.accept(new Visitor() {

                            public void visit(Object obj)

                                    throws VisitCanceledException, BaseException {

                                Feature feature = (Feature) obj;

                                Geometry geometry

                                        = feature.getDefaultGeometry();

                                if (!isValidGeometryToSelect(geometry)) {

                                    throw new InvalidEntryException(null);

                                }

                        });

                        values.put(parameter, featureSelection);

                        return;

                    } catch (BaseException e) {

                        throw new InvalidEntryException(e);

                    }

        } else if (parameter == geometryToTrimWithParameter && value instanceof Point) {

            if (value instanceof Point) {

                Point point = (Point) value;

                Geometry geometry = getGeometry(point); //editingProviderServices.getGeometryOfVisibleLayers(point, featureStore, mapContext);

                if (geometry != null) {

                    try {

                        values.put(parameter, geometry.toLines());

                    } catch (GeometryException ex) {

                        throw new InvalidEntryException(ex);

                    }

        } else if (parameter == shearingPointParameter && value instanceof Point) {

            if (value instanceof Point) {

                Point point = (Point) value;

                values.put(parameter, point);

                return;

            }

    private boolean isValidGeometryToSelect(Geometry geometry) {

        GeometryType geoType

                = geometry.getGeometryType();

        if (!geoType.isTypeOf(CURVE)

                && !geoType.isTypeOf(MULTICURVE)) {

            return false;

        }

        if (geoType.isTypeOf(CURVE)) {

            if (geometry instanceof Line ) {

                Line line = (Line) geometry;

                return !line.isClosed();

            }

            if (geometry instanceof Arc ) {

                Arc arc = (Arc) geometry;

                return !arc.getInitPoint().equals(arc.getEndPoint());

            }

            return false;

        }

        if (geoType.isTypeOf(MULTICURVE)) {

            MultiCurve multiCurve = (MultiCurve) geometry;

            for (Geometry geom : multiCurve) {

                if (!isValidGeometryToSelect(geom)) {

                    return false;

                }

            }

        }

        return true;

    }

    private Geometry getGeometry(Point point) {

        EditingProviderServices editingProviderServices = (EditingProviderServices) getProviderServices();

        Geometry geometry = editingProviderServices.getGeometryOfVisibleLayers(point, featureStore, mapContext);

        return geometry;

    @Override

    @Override

        FeatureSelection selection = (FeatureSelection) values.get(selectionParameter);

        Geometry shearsGeometry = (Geometry) values.get(geometryToTrimWithParameter);

        Point point = (Point) values.get(shearingPointParameter);

        if (selection != null && shearsGeometry != null && point != null) {

                DisposableIterator selectionIterator = null;

                selectionIterator = selection.fastIterator();

                while (selectionIterator.hasNext()) {

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

                    Geometry geometry = feature.getDefaultGeometry();

                    EditableFeature eFeature = feature.getEditable();

                    if(geometry.intersects(shearsGeometry)){

                                trimLine(point, curveToTrim, shearsGeometry);

                            selection.update(eFeature);

                            MultiCurve trimmedMultiCurve =

                                Curve primitive =

                                    primitive.distance(point);

                                trimLine(point, multiCurveToTrim

                                    .getCurveAt(nearestCurveIndex), shearsGeometry);

                                trimmedMultiCurve.addCurve(result.getCurveAt(i));

                                    trimmedMultiCurve.addCurve(multiCurveToTrim

                            eFeature.setDefaultGeometry(trimmedMultiCurve);

                            selection.update(eFeature);

                }  

            } catch (BaseException ex) {

                throw new FinishServiceException(ex);

    @Override

        this.values = new HashMap<>();

        if (featureStore != null && values.get(selectionParameter) == null) {

    @Override