Examples with Vertex com.revolsys.geometry.model.vertex.Vertex used on opensource projects

Example 31 with Vertex

use of com.revolsys.geometry.model.vertex.Vertex in project com.revolsys.open by revolsys.

the class Lineal method addIsSimpleErrors.

static boolean addIsSimpleErrors(final Lineal lineal, final List<GeometryValidationError> errors, final boolean shortCircuit) {
    final LineSegmentIndex index = new LineSegmentIndex(lineal);
    for (final Segment segment : lineal.segments()) {
        final int segmentIndex = segment.getSegmentIndex();
        final int partIndex = segment.getPartIndex();
        if (segment.getLength() == 0) {
            errors.add(new DuplicateVertexError(segment.getGeometryVertex(0)));
        } else {
            final List<LineSegment> segments = index.queryBoundingBox(segment);
            for (final LineSegment lineSegment : segments) {
                final Segment segment2 = (Segment) lineSegment;
                final int partIndex2 = segment2.getPartIndex();
                final int segmentIndex2 = segment2.getSegmentIndex();
                if (partIndex2 > partIndex || partIndex == partIndex2 && segmentIndex2 > segmentIndex) {
                    if (segment.equals(lineSegment)) {
                        final SelfOverlapSegmentError error = new SelfOverlapSegmentError(segment);
                        errors.add(error);
                        if (shortCircuit) {
                            return false;
                        }
                    } else {
                        final Geometry intersection = segment.getIntersection(lineSegment);
                        if (intersection instanceof Point) {
                            final Point pointIntersection = (Point) intersection;
                            boolean isIntersection = true;
                            // Process segments on the same linestring part
                            if (partIndex == partIndex2) {
                                // segment
                                if (segmentIndex + 1 == segmentIndex2) {
                                    if (lineSegment.equalsVertex(2, 0, pointIntersection)) {
                                        isIntersection = false;
                                    }
                                // A loop can touch itself at the start/end
                                } else if (segment.isLineClosed()) {
                                    if (segment.isLineStart() && segment2.isLineEnd()) {
                                        if (segment.equalsVertex(2, 0, pointIntersection)) {
                                            isIntersection = false;
                                        }
                                    }
                                }
                            } else {
                                if (!segment.isLineClosed() && !segment2.isLineClosed()) {
                                    final boolean segment1EndIntersection = segment.isEndIntersection(pointIntersection);
                                    final boolean segment2EndIntersection = segment2.isEndIntersection(pointIntersection);
                                    if (segment1EndIntersection && segment2EndIntersection) {
                                        isIntersection = false;
                                    }
                                }
                            }
                            if (isIntersection) {
                                GeometryValidationError error;
                                if (segment.equalsVertex(2, 0, pointIntersection)) {
                                    final Vertex vertex = segment.getGeometryVertex(0);
                                    error = new SelfIntersectionVertexError(vertex);
                                } else if (segment.equalsVertex(2, 1, pointIntersection)) {
                                    final Vertex vertex = segment.getGeometryVertex(1);
                                    error = new SelfIntersectionVertexError(vertex);
                                } else {
                                    error = new SelfIntersectionPointError(lineal, pointIntersection);
                                }
                                errors.add(error);
                                if (shortCircuit) {
                                    return false;
                                }
                            }
                        } else if (intersection instanceof LineSegment) {
                            final LineSegment lineIntersection = (LineSegment) intersection;
                            GeometryValidationError error;
                            if (segment.equals(lineIntersection)) {
                                error = new SelfOverlapSegmentError(segment);
                            } else if (lineSegment.equals(lineIntersection)) {
                                error = new SelfOverlapSegmentError(segment2);
                            } else {
                                error = new SelfOverlapLineSegmentError(lineal, lineIntersection);
                            }
                            errors.add(error);
                            if (shortCircuit) {
                                return false;
                            }
                        }
                    }
                }
            }
        }
    }
    return errors.isEmpty();
}

Example 32 with Vertex

use of com.revolsys.geometry.model.vertex.Vertex in project com.revolsys.open by revolsys.

the class MultiPoint method pointVertices.

@Override
default List<Vertex> pointVertices() {
    if (isEmpty()) {
        return Collections.emptyList();
    } else {
        final int vertexCount = getVertexCount();
        final List<Vertex> vertices = new ArrayList<>(vertexCount);
        for (int i = 0; i < vertexCount; i++) {
            final MultiPointVertex vertex = new MultiPointVertex(this, i);
            vertices.add(vertex);
        }
        return vertices;
    }
}

Example 33 with Vertex

use of com.revolsys.geometry.model.vertex.Vertex in project com.revolsys.open by revolsys.

the class LineString method findClosestGeometryComponent.

@Override
default Pair<GeometryComponent, Double> findClosestGeometryComponent(final double x, final double y) {
    if (isEmpty()) {
        return new Pair<>();
    } else {
        final GeometryFactory geometryFactory = getGeometryFactory();
        boolean closestIsVertex = false;
        int closestIndex = 0;
        double x1 = getX(0);
        double y1 = getY(0);
        if (x == x1 && y == y1) {
            final AbstractVertex closestVertex = getVertex(0);
            return new Pair<>(closestVertex, 0.0);
        } else {
            double closestDistance = geometryFactory.makePrecise(0, MathUtil.distance(x, y, x1, y1));
            final int vertexCount = getVertexCount();
            for (int vertexIndex = 1; vertexIndex < vertexCount; vertexIndex++) {
                final double x2 = getX(vertexIndex);
                final double y2 = getY(vertexIndex);
                if (x == x2 && y == y2) {
                    final AbstractVertex closestVertex = getVertex(vertexIndex);
                    return new Pair<>(closestVertex, 0.0);
                } else {
                    final double toDistance = geometryFactory.makePrecise(0, MathUtil.distance(x, y, x2, y2));
                    if (toDistance <= closestDistance) {
                        if (!closestIsVertex || toDistance < closestDistance) {
                            closestIndex = vertexIndex;
                            closestIsVertex = true;
                            closestDistance = toDistance;
                        }
                    }
                    final double segmentDistance = geometryFactory.makePrecise(0, LineSegmentUtil.distanceLinePoint(x1, y1, x2, y2, x, y));
                    if (segmentDistance == 0) {
                        final Segment closestSegment = getSegment(vertexIndex - 1);
                        return new Pair<>(closestSegment, 0.0);
                    } else if (segmentDistance < closestDistance) {
                        closestIsVertex = false;
                        closestIndex = vertexIndex - 1;
                        closestDistance = segmentDistance;
                    }
                }
                x1 = x2;
                y1 = y2;
            }
            if (closestIsVertex) {
                final Vertex closestVertex = getVertex(closestIndex);
                return new Pair<>(closestVertex, closestDistance);
            } else {
                final Segment closestSegment = getSegment(closestIndex);
                return new Pair<>(closestSegment, closestDistance);
            }
        }
    }
}

Example 34 with Vertex

use of com.revolsys.geometry.model.vertex.Vertex in project com.revolsys.open by revolsys.

the class Geometry method findClosestGeometryComponent.

default Pair<GeometryComponent, Double> findClosestGeometryComponent(final double x, final double y, final double maxDistance) {
    if (isEmpty()) {
        return new Pair<>();
    } else {
        GeometryComponent closestComponent = null;
        double closestDistance = Double.POSITIVE_INFINITY;
        for (final Segment segment : segments()) {
            boolean matched = false;
            if (segment.isLineStart()) {
                final Vertex from = segment.getGeometryVertex(0);
                if (from.equalsVertex(x, y)) {
                    return new Pair<>(from, 0.0);
                } else {
                    final double fromDistance = from.distance(x, y);
                    if (fromDistance <= maxDistance) {
                        if (// 
                        fromDistance < closestDistance || fromDistance == closestDistance && !(closestComponent instanceof Vertex)) {
                            closestDistance = fromDistance;
                            closestComponent = from.clone();
                            matched = true;
                        }
                    }
                }
            }
            {
                final Vertex to = segment.getGeometryVertex(1);
                if (to.equalsVertex(x, y)) {
                    return new Pair<>(to, 0.0);
                } else {
                    final double toDistance = to.distance(x, y);
                    if (toDistance <= maxDistance) {
                        if (// 
                        toDistance < closestDistance || toDistance == closestDistance && !(closestComponent instanceof Vertex)) {
                            closestDistance = toDistance;
                            closestComponent = to.clone();
                            matched = true;
                        }
                    }
                }
            }
            if (!matched) {
                final double segmentDistance = segment.distance(x, y);
                if (segmentDistance == 0) {
                    return new Pair<>(segment, 0.0);
                } else if (segmentDistance <= maxDistance) {
                    if (// 
                    segmentDistance < closestDistance || segmentDistance == closestDistance && !(closestComponent instanceof Vertex)) {
                        closestDistance = segmentDistance;
                        closestComponent = segment.clone();
                    }
                }
            }
        }
        if (Double.isFinite(closestDistance)) {
            return new Pair<>(closestComponent, closestDistance);
        } else {
            return new Pair<>();
        }
    }
}

Example 35 with Vertex

use of com.revolsys.geometry.model.vertex.Vertex in project com.revolsys.open by revolsys.

the class PointQuadTree method get.

public static PointQuadTree<int[]> get(final Geometry geometry) {
    if (Property.hasValue(geometry)) {
        PointQuadTree<int[]> index = CACHE.get(geometry);
        if (index == null) {
            final GeometryFactory geometryFactory = geometry.getGeometryFactory();
            index = new PointQuadTree<>(geometryFactory);
            for (final Vertex vertex : geometry.vertices()) {
                final double x = vertex.getX();
                final double y = vertex.getY();
                final int[] vertexId = vertex.getVertexId();
                index.put(x, y, vertexId);
            }
            CACHE.put(geometry, index);
        }
        return index;
    } else {
        return null;
    }
}