Examples with Edge com.revolsys.geometry.graph.Edge used on opensource projects

Example 21 with Edge

use of com.revolsys.geometry.graph.Edge in project com.revolsys.open by revolsys.

the class LineMatchGraph method getMatchedLines.

public Lineal getMatchedLines(final int index) {
    final List<LineString> lines = new ArrayList<>();
    final Set<Edge<LineSegmentMatch>> processedEdges = new HashSet<>();
    for (Node<LineSegmentMatch> currentNode : getStartNodes(index)) {
        final List<Point> coordinates = new ArrayList<>();
        while (currentNode != null) {
            Node<LineSegmentMatch> nextNode = null;
            final List<Edge<LineSegmentMatch>> edges = currentNode.getOutEdges();
            for (final Edge<LineSegmentMatch> edge : edges) {
                final LineSegmentMatch lineSegmentMatch = edge.getObject();
                if (lineSegmentMatch.hasSegment(index) && !processedEdges.contains(edge)) {
                    if (lineSegmentMatch.hasMatches(index)) {
                        if (coordinates.isEmpty()) {
                            final Point startCoordinate = currentNode;
                            coordinates.add(startCoordinate);
                        }
                        final Node<LineSegmentMatch> toNode = edge.getOppositeNode(currentNode);
                        final Point toCoordinate = toNode;
                        coordinates.add(toCoordinate);
                    } else {
                        newLine(lines, coordinates);
                        coordinates.clear();
                    }
                    processedEdges.add(edge);
                    nextNode = edge.getOppositeNode(currentNode);
                }
            }
            currentNode = nextNode;
        }
        newLine(lines, coordinates);
    }
    return this.geometryFactory.lineal(lines);
}

Example 22 with Edge

use of com.revolsys.geometry.graph.Edge in project com.revolsys.open by revolsys.

the class GeometryGraph method getGeometry.

/**
 * Only currently works for lines and points.
 *
 * @return
 */
public Geometry getGeometry() {
    removeDuplicateLineEdges();
    final EdgeAttributeValueComparator<LineSegment> comparator = new EdgeAttributeValueComparator<>("geometryIndex", "partIndex", "segmentIndex");
    final List<Geometry> geometries = new ArrayList<>(this.points);
    final GeometryFactory geometryFactory = getGeometryFactory();
    final List<Point> points = new ArrayList<>();
    final Consumer<Edge<LineSegment>> action = new Consumer<Edge<LineSegment>>() {

        private Node<LineSegment> previousNode = null;

        @Override
        public void accept(final Edge<LineSegment> edge) {
            final LineSegment lineSegment = edge.getObject();
            if (lineSegment.getLength() > 0) {
                final Node<LineSegment> fromNode = edge.getFromNode();
                final Node<LineSegment> toNode = edge.getToNode();
                if (this.previousNode == null) {
                    points.add(lineSegment.getPoint(0));
                    points.add(lineSegment.getPoint(1));
                } else if (fromNode == this.previousNode) {
                    if (edge.getLength() > 0) {
                        points.add(toNode);
                    }
                } else {
                    if (points.size() > 1) {
                        final LineString line = geometryFactory.lineString(points);
                        geometries.add(line);
                    }
                    points.clear();
                    ;
                    points.add(lineSegment.getPoint(0));
                    points.add(lineSegment.getPoint(1));
                }
                if (points.size() > 1) {
                    final int toDegree = toNode.getDegree();
                    if (toDegree != 2) {
                        final LineString line = geometryFactory.lineString(points);
                        geometries.add(line);
                        points.clear();
                        ;
                        points.add(toNode);
                    }
                }
                this.previousNode = toNode;
            }
        }
    };
    forEachEdge(comparator, action);
    if (points.size() > 1) {
        final LineString line = geometryFactory.lineString(points);
        geometries.add(line);
    }
    return geometryFactory.geometry(geometries);
}

Example 23 with Edge

use of com.revolsys.geometry.graph.Edge in project com.revolsys.open by revolsys.

the class GeometryGraph method removeDuplicateLineEdges.

public void removeDuplicateLineEdges() {
    final Comparator<Edge<LineSegment>> comparator = new EdgeAttributeValueComparator<>("geometryIndex", "partIndex", "segmentIndex");
    forEachEdge(comparator, (edge) -> {
        if (isLineString(edge)) {
            final Node<LineSegment> fromNode = edge.getFromNode();
            final Node<LineSegment> toNode = edge.getToNode();
            final Collection<Edge<LineSegment>> edges = fromNode.getEdgesTo(toNode);
            final int duplicateCount = edges.size();
            if (duplicateCount > 1) {
                edges.remove(edge);
                for (final Edge<LineSegment> removeEdge : edges) {
                    if (isLineString(removeEdge)) {
                        removeEdge.remove();
                    }
                }
            }
        }
    });
}

Example 24 with Edge

use of com.revolsys.geometry.graph.Edge in project com.revolsys.open by revolsys.

the class GeometryGraph method intersects.

public boolean intersects(final LineString line) {
    BoundingBox boundingBox = line.getBoundingBox();
    final double scaleXY = getGeometryFactory().getScaleXY();
    double maxDistance = 0;
    if (scaleXY > 0) {
        maxDistance = 1 / scaleXY;
    }
    boundingBox = boundingBox.expand(maxDistance);
    if (boundingBox.intersects(this.boundingBox)) {
        final LineString points = line;
        final int numPoints = points.getVertexCount();
        final Point fromPoint = points.getPoint(0);
        final Point toPoint = points.getPoint(numPoints - 1);
        Point previousPoint = fromPoint;
        for (int i = 1; i < numPoints; i++) {
            final Point nextPoint = points.getPoint(i);
            final LineSegment line1 = new LineSegmentDoubleGF(previousPoint, nextPoint);
            final List<Edge<LineSegment>> edges = EdgeLessThanDistance.getEdges(this, line1, maxDistance);
            for (final Edge<LineSegment> edge2 : edges) {
                final LineSegment line2 = edge2.getObject();
                final Geometry intersections = line1.getIntersection(line2);
                for (final Point intersection : intersections.vertices()) {
                    if (intersection.equals(fromPoint) || intersection.equals(toPoint)) {
                        // Point intersection, make sure it's not at the start
                        final Node<LineSegment> node = findNode(intersection);
                        final int degree = node.getDegree();
                        if (isStartPoint(node)) {
                            if (degree > 2) {
                                // into account loops
                                return true;
                            }
                        } else if (degree > 1) {
                            // Intersection not at the start/end of the other line
                            return true;
                        }
                    } else {
                        // Intersection not at the start/end of the line
                        return true;
                    }
                }
                for (final Point point : line1.vertices()) {
                    if (line2.distancePoint(point) < maxDistance) {
                        if (point.equals(fromPoint) || point.equals(toPoint)) {
                            // Point intersection, make sure it's not at the start
                            final double maxDistance1 = maxDistance;
                            for (final Node<LineSegment> node : this.getNodes(point, maxDistance1)) {
                                final int degree = node.getDegree();
                                if (isStartPoint(node)) {
                                    if (degree > 2) {
                                        // into account loops
                                        return true;
                                    }
                                } else if (degree > 1) {
                                    // Intersection not at the start/end of the other line
                                    return true;
                                }
                            }
                        } else {
                            // Intersection not at the start/end of the line
                            return true;
                        }
                    }
                }
            }
            previousPoint = nextPoint;
        }
    }
    return false;
}

Example 25 with Edge

use of com.revolsys.geometry.graph.Edge in project com.revolsys.open by revolsys.

the class GeometryGraph method getBoundaryIntersection.

/**
 * Get the intersection between the line and the boundary of this geometry.
 *
 * @param line
 * @return
 */
public Geometry getBoundaryIntersection(final LineString line) {
    final List<Point> pointIntersections = new ArrayList<>();
    final List<LineString> lineIntersections = new ArrayList<>();
    final GeometryFactory geometryFactory = getGeometryFactory();
    final BoundingBox boundingBox = getBoundingBox(line);
    if (boundingBox.intersects(this.boundingBox)) {
        final LineString points = line;
        final int vertexCount = points.getVertexCount();
        final Point fromPoint = points.getPoint(0);
        final Point toPoint = points.getPoint(vertexCount - 1);
        Point previousPoint = fromPoint;
        for (int vertexIndex = 1; vertexIndex < vertexCount; vertexIndex++) {
            final Point nextPoint = points.getPoint(vertexIndex);
            final LineSegment line1 = new LineSegmentDoubleGF(getGeometryFactory(), previousPoint, nextPoint);
            final List<Edge<LineSegment>> edges = EdgeLessThanDistance.getEdges(this, line1, this.maxDistance);
            for (final Edge<LineSegment> edge2 : edges) {
                final LineSegment line2 = edge2.getObject();
                final Geometry segmentIntersection = line1.getIntersection(line2);
                if (segmentIntersection instanceof Point) {
                    final Point intersection = (Point) segmentIntersection;
                    if (intersection.equals(fromPoint) || intersection.equals(toPoint)) {
                        // Point intersection, make sure it's not at the start
                        final Node<LineSegment> node = findNode(intersection);
                        if (node == null) {
                            pointIntersections.add(geometryFactory.point(intersection));
                        } else {
                            final int degree = node.getDegree();
                            if (isStartPoint(node)) {
                                if (degree > 2) {
                                    // Intersection not at the start/end of the other line,
                                    // taking
                                    // into account loops
                                    pointIntersections.add(geometryFactory.point(intersection));
                                }
                            } else if (degree > 1) {
                                // Intersection not at the start/end of the other line
                                pointIntersections.add(geometryFactory.point(intersection));
                            }
                        }
                    } else {
                        // Intersection not at the start/end of the line
                        pointIntersections.add(geometryFactory.point(intersection));
                    }
                } else if (segmentIntersection instanceof LineSegment) {
                    lineIntersections.add((LineSegment) segmentIntersection);
                }
                for (final Point point : line1.vertices()) {
                    if (line2.distancePoint(point) < this.maxDistance) {
                        if (point.equals(fromPoint) || point.equals(toPoint)) {
                            // Point intersection, make sure it's not at the start
                            final double maxDistance1 = this.maxDistance;
                            for (final Node<LineSegment> node : this.getNodes(point, maxDistance1)) {
                                final int degree = node.getDegree();
                                if (isStartPoint(node)) {
                                    if (degree > 2) {
                                        // Intersection not at the start/end of the other line,
                                        // taking
                                        // into account loops
                                        pointIntersections.add(geometryFactory.point(point));
                                    }
                                } else if (degree > 1) {
                                    // Intersection not at the start/end of the other line
                                    pointIntersections.add(geometryFactory.point(point));
                                }
                            }
                        } else {
                            // Intersection not at the start/end of the line
                            pointIntersections.add(geometryFactory.point(point));
                        }
                    }
                }
            }
            previousPoint = nextPoint;
        }
    }
    if (lineIntersections.isEmpty()) {
        return geometryFactory.punctual(pointIntersections);
    } else {
        final List<LineString> mergedLines = LineMerger.merge(lineIntersections);
        final Lineal multiLine = geometryFactory.lineal(mergedLines);
        if (pointIntersections.isEmpty()) {
            return multiLine;
        } else {
            final Punctual multiPoint = geometryFactory.punctual(pointIntersections);
            return multiPoint.union(multiLine);
        }
    }
}