/** * Returns the coordinate of the from-node. */ public Coordinate getCoordinate() { return from.getCoordinate(); } /**
private void buildEdgeStringsForUnprocessedNodes() { for (Iterator i = graph.getNodes().iterator(); i.hasNext(); ) { Node node = (Node) i.next(); if (!node.isMarked()) { Assert.isTrue(node.getDegree() == 2); buildEdgeStringsStartingAt(node); node.setMarked(true); } } } private void buildEdgeStringsForNonDegree2Nodes() {
/** * 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); } }
private Node getNode(Coordinate coordinate) { Node node = findNode(coordinate); if (node == null) { node = new Node(coordinate); add(node); } return node; } }
/** * 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 static int getDegree(Node node, long label) { List edges = node.getOutEdges().getEdges(); int degree = 0; for (Iterator i = edges.iterator(); i.hasNext(); ) { PolygonizeDirectedEdge de = (PolygonizeDirectedEdge) i.next(); if (de.getLabel() == label) degree++; } return degree; }
/** * Returns the directed edge that starts at this directed edge's end point, or null * if there are zero or multiple directed edges starting there. * @return the directed edge */ public LineMergeDirectedEdge getNext() { if (getToNode().getDegree() != 2) { return null; } if (getToNode().getOutEdges().getEdges().get(0) == getSym()) { return (LineMergeDirectedEdge) getToNode().getOutEdges().getEdges().get(1); } Assert.isTrue(getToNode().getOutEdges().getEdges().get(1) == getSym()); return (LineMergeDirectedEdge) getToNode().getOutEdges().getEdges().get(0); } }
private static Node findLowestDegreeNode(Subgraph graph) { int minDegree = Integer.MAX_VALUE; Node minDegreeNode = null; for (Iterator i = graph.nodeIterator(); i.hasNext(); ) { Node node = (Node) i.next(); if (minDegreeNode == null || node.getDegree() < minDegree) { minDegree = node.getDegree(); minDegreeNode = node; } } return minDegreeNode; }
public List getConnectedSubgraphs() { List subgraphs = new ArrayList(); GraphComponent.setVisited(graph.nodeIterator(), false); for (Iterator i = graph.edgeIterator(); i.hasNext(); ) { Edge e = (Edge) i.next(); Node node = e.getDirEdge(0).getFromNode(); if (! node.isVisited()) { subgraphs.add(findSubgraph(node)); } } return subgraphs; }
/** * Initializes this Edge's two DirectedEdges, and for each DirectedEdge: sets the * Edge, sets the symmetric DirectedEdge, and adds this Edge to its from-Node. */ public void setDirectedEdges(DirectedEdge de0, DirectedEdge de1) { dirEdge = new DirectedEdge[] { de0, de1 }; de0.setEdge(this); de1.setEdge(this); de0.setSym(de1); de1.setSym(de0); de0.getFromNode().addOutEdge(de0); de1.getFromNode().addOutEdge(de1); }
/** * Removes a {@link DirectedEdge} from its from-{@link Node} and from this graph. * This method does not remove the {@link Node}s associated with the DirectedEdge, * even if the removal of the DirectedEdge reduces the degree of a Node to zero. */ public void remove(DirectedEdge de) { DirectedEdge sym = de.getSym(); if (sym != null) sym.setSym(null); de.getFromNode().remove(de); de.remove(); dirEdges.remove(de); }
private Node getNode(Coordinate pt) { Node node = findNode(pt); if (node == null) { node = new Node(pt); // ensure node is only added once to graph add(node); } return node; }
private static int getDegreeNonDeleted(Node node) { List edges = node.getOutEdges().getEdges(); int degree = 0; for (Iterator i = edges.iterator(); i.hasNext(); ) { PolygonizeDirectedEdge de = (PolygonizeDirectedEdge) i.next(); if (! de.isMarked()) degree++; } return degree; }
/** * Returns all Nodes with the given number of Edges around it. */ public List findNodesOfDegree(int degree) { List nodesFound = new ArrayList(); for (Iterator i = nodeIterator(); i.hasNext(); ) { Node node = (Node) i.next(); if (node.getDegree() == degree) nodesFound.add(node); } return nodesFound; }
public void testDirectedEdgeComparator() { DirectedEdge d1 = new DirectedEdge(new Node(new Coordinate(0, 0)), new Node(new Coordinate(10, 10)), new Coordinate(10, 10), true); DirectedEdge d2 = new DirectedEdge(new Node(new Coordinate(0, 0)), new Node(new Coordinate(20, 20)), new Coordinate(20, 20), false); assertEquals(0, d2.compareTo(d1)); }
/** * Returns all Edges that connect the two nodes (which are assumed to be different). */ public static Collection getEdgesBetween(Node node0, Node node1) { List edges0 = DirectedEdge.toEdges(node0.getOutEdges().getEdges()); Set commonEdges = new HashSet(edges0); List edges1 = DirectedEdge.toEdges(node1.getOutEdges().getEdges()); commonEdges.retainAll(edges1); return commonEdges; }
/** * Tests whether a complete unique path exists in a graph * using Euler's Theorem. * * @param graph the subgraph containing the edges * @return <code>true</code> if a sequence exists */ private boolean hasSequence(Subgraph graph) { int oddDegreeCount = 0; for (Iterator i = graph.nodeIterator(); i.hasNext(); ) { Node node = (Node) i.next(); if (node.getDegree() % 2 == 1) oddDegreeCount++; } return oddDegreeCount <= 2; }
/** * Adds a node to the map, replacing any that is already at that location. * @return the added node */ public Node add(Node n) { nodeMap.put(n.getCoordinate(), n); return n; }
public void testDirectedEdgeToEdges() { DirectedEdge d1 = new DirectedEdge(new Node(new Coordinate(0, 0)), new Node(new Coordinate(10, 10)), new Coordinate(10, 10), true); DirectedEdge d2 = new DirectedEdge(new Node(new Coordinate(20, 0)), new Node(new Coordinate(20, 10)), new Coordinate(20, 10), false); List edges = DirectedEdge.toEdges(Arrays.asList(new Object[]{d1, d2})); assertEquals(2, edges.size()); assertNull(edges.get(0)); assertNull(edges.get(1)); }