/** * Returns the zero-based index of the given Edge, after sorting in ascending order * by angle with the positive x-axis. */ public int getIndex(Edge edge) { sortEdges(); for (int i = 0; i < outEdges.size(); i++) { DirectedEdge de = (DirectedEdge) outEdges.get(i); if (de.getEdge() == edge) return i; } return -1; } /**
/** * Finds an {@link DirectedEdge} for an unvisited edge (if any), * choosing the dirEdge which preserves orientation, if possible. * * @param node the node to examine * @return the dirEdge found, or <code>null</code> if none were unvisited */ private static DirectedEdge findUnvisitedBestOrientedDE(Node node) { DirectedEdge wellOrientedDE = null; DirectedEdge unvisitedDE = null; for (Iterator i = node.getOutEdges().iterator(); i.hasNext(); ) { DirectedEdge de = (DirectedEdge) i.next(); if (! de.getEdge().isVisited()) { unvisitedDE = de; if (de.getEdgeDirection()) wellOrientedDE = de; } } if (wellOrientedDE != null) return wellOrientedDE; return unvisitedDE; }
/** * Builds a geometry ({@link LineString} or {@link MultiLineString} ) * representing the sequence. * * @param sequences a List of Lists of DirectedEdges with * LineMergeEdges as their parent edges. * @return the sequenced geometry, or <code>null</code> if no sequence exists */ private Geometry buildSequencedGeometry(List sequences) { List lines = new ArrayList(); for (Iterator i1 = sequences.iterator(); i1.hasNext(); ) { List seq = (List) i1.next(); for (Iterator i2 = seq.iterator(); i2.hasNext(); ) { DirectedEdge de = (DirectedEdge) i2.next(); LineMergeEdge e = (LineMergeEdge) de.getEdge(); LineString line = e.getLine(); LineString lineToAdd = line; if (! de.getEdgeDirection() && ! line.isClosed()) lineToAdd = reverse(line); lines.add(lineToAdd); } } if (lines.size() == 0) return factory.createMultiLineString(new LineString[0]); return factory.buildGeometry(lines); }
/** * Adds the argument node and all its out edges to the subgraph. * @param node the node to add * @param nodeStack the current set of nodes being traversed */ private void addEdges(Node node, Stack nodeStack, Subgraph subgraph) { node.setVisited(true); for (Iterator i = ((DirectedEdgeStar) node.getOutEdges()).iterator(); i.hasNext(); ) { DirectedEdge de = (DirectedEdge) i.next(); subgraph.add(de.getEdge()); Node toNode = de.getToNode(); if (! toNode.isVisited()) nodeStack.push(toNode); } }
/** * Computes the list of coordinates which are contained in this ring. * The coordinates are computed once only and cached. * * @return an array of the {@link Coordinate}s in this ring */ private Coordinate[] getCoordinates() { if (ringPts == null) { CoordinateList coordList = new CoordinateList(); for (Iterator i = deList.iterator(); i.hasNext(); ) { DirectedEdge de = (DirectedEdge) i.next(); PolygonizeEdge edge = (PolygonizeEdge) de.getEdge(); addEdge(edge.getLine().getCoordinates(), de.getEdgeDirection(), coordList); } ringPts = coordList.toCoordinateArray(); } return ringPts; }
/** * Removes a node from the graph, along with any associated DirectedEdges and * Edges. */ public void remove(Node node) { // unhook all directed edges List outEdges = node.getOutEdges().getEdges(); for (Iterator i = outEdges.iterator(); i.hasNext(); ) { DirectedEdge de = (DirectedEdge) i.next(); DirectedEdge sym = de.getSym(); // remove the diredge that points to this node if (sym != null) remove(sym); // remove this diredge from the graph collection dirEdges.remove(de); Edge edge = de.getEdge(); if (edge != null) { edges.remove(edge); } } // remove the node from the graph nodeMap.remove(node.getCoordinate()); node.remove(); }
private void addReverseSubpath(DirectedEdge de, ListIterator lit, boolean expectedClosed) { // trace an unvisited path *backwards* from this de Node endNode = de.getToNode(); Node fromNode = null; while (true) { lit.add(de.getSym()); de.getEdge().setVisited(true); fromNode = de.getFromNode(); DirectedEdge unvisitedOutDE = findUnvisitedBestOrientedDE(fromNode); // this must terminate, since we are continually marking edges as visited if (unvisitedOutDE == null) break; de = unvisitedOutDE.getSym(); } if (expectedClosed) { // the path should end at the toNode of this de, otherwise we have an error Assert.isTrue(fromNode == endNode, "path not contiguous"); } }