Index: src/org/openstreetmap/josm/data/osm/NodeGraph.java =================================================================== --- src/org/openstreetmap/josm/data/osm/NodeGraph.java (revision 18644) +++ src/org/openstreetmap/josm/data/osm/NodeGraph.java (working copy) @@ -5,20 +5,14 @@ import java.util.ArrayList; import java.util.Collection; import java.util.Collections; -import java.util.Comparator; import java.util.Deque; import java.util.HashMap; import java.util.HashSet; -import java.util.LinkedHashMap; import java.util.LinkedHashSet; +import java.util.LinkedList; import java.util.List; -import java.util.Map; -import java.util.Map.Entry; import java.util.Optional; import java.util.Set; -import java.util.TreeMap; -import java.util.stream.Collectors; -import java.util.stream.Stream; import org.openstreetmap.josm.tools.Pair; @@ -124,12 +118,12 @@ public static NodeGraph createNearlyUndirectedGraphFromNodeWays(Collection ways) { boolean dir = true; NodeGraph graph = new NodeGraph(); + Optional dirWay = ways.stream().filter(w -> !w.isNew()).findFirst(); + if (dirWay.isPresent()) { + graph.add(buildNodePairs(dirWay.get(), true /* directed */)); + } for (Way w: ways) { - if (!w.isNew()) { - /* let the first non-new way give the direction (see #5880) */ - graph.add(buildNodePairs(w, dir)); - dir = false; - } else { + if (!dirWay.isPresent() || w != dirWay.get()) { graph.add(buildNodePairs(w, false /* undirected */)); } } @@ -140,48 +134,40 @@ private int numUndirectedEges; /** counts the number of edges that were added */ private int addedEdges; - private final Map> successors = new LinkedHashMap<>(); - private final Map> predecessors = new LinkedHashMap<>(); + private LinkedList[] adj; + private List allNodes; - protected void rememberSuccessor(NodePair pair) { - List l = successors.computeIfAbsent(pair.getA(), k -> new ArrayList<>()); - if (!l.contains(pair)) { - l.add(pair); - } - } - - protected void rememberPredecessors(NodePair pair) { - List l = predecessors.computeIfAbsent(pair.getB(), k -> new ArrayList<>()); - if (!l.contains(pair)) { - l.add(pair); - } - } - - protected boolean isTerminalNode(Node n) { - if (successors.get(n) == null) return false; - if (successors.get(n).size() != 1) return false; - if (predecessors.get(n) == null) return true; - if (predecessors.get(n).size() == 1) { - NodePair p1 = successors.get(n).get(0); - NodePair p2 = predecessors.get(n).get(0); - return p1.equals(p2.swap()); - } - return false; - } - + @SuppressWarnings("unchecked") protected void prepare() { Set undirectedEdges = new LinkedHashSet<>(); - successors.clear(); - predecessors.clear(); for (NodePair pair: edges) { if (!undirectedEdges.contains(pair) && !undirectedEdges.contains(pair.swap())) { undirectedEdges.add(pair); } - rememberSuccessor(pair); - rememberPredecessors(pair); } numUndirectedEges = undirectedEdges.size(); + + // calculate an index for each node contained in this graph + allNodes = Collections.unmodifiableList(new ArrayList<>(getNodes())); + + // calculate the adjacency list representation. each node is represented by an integer 0...n + // which refers to the position in the list allNodes + adj = new LinkedList[allNodes.size()]; + for (int i = 0; i < allNodes.size(); i++) { + adj[i] = new LinkedList<>(); + } + // map the nodes in this graph to an Integer + HashMap nodeIdMap = new HashMap<>(); + for (int i = 0; i < allNodes.size(); i++) { + nodeIdMap.put(allNodes.get(i), i); + } + + for (NodePair edge : undirectedEdges) { + int idxA = nodeIdMap.get(edge.getA()); + int idxB = nodeIdMap.get(edge.getB()); + addEdge(idxA, idxB); + } } /** @@ -210,25 +196,6 @@ } } - protected Set getTerminalNodes() { - return getNodes().stream().filter(this::isTerminalNode).collect(Collectors.toCollection(LinkedHashSet::new)); - } - - private List getConnectedPairs(Node node) { - List connected = new ArrayList<>(); - connected.addAll(Optional.ofNullable(successors.get(node)).orElseGet(Collections::emptyList)); - connected.addAll(Optional.ofNullable(predecessors.get(node)).orElseGet(Collections::emptyList)); - return connected; - } - - protected List getOutboundPairs(NodePair pair) { - return getOutboundPairs(pair.getB()); - } - - protected List getOutboundPairs(Node node) { - return Optional.ofNullable(successors.get(node)).orElseGet(Collections::emptyList); - } - protected Set getNodes() { Set nodes = new LinkedHashSet<>(2 * edges.size()); for (NodePair pair: edges) { @@ -238,47 +205,7 @@ return nodes; } - protected boolean isSpanningWay(Collection way) { - return numUndirectedEges == way.size(); - } - - protected List buildPathFromNodePairs(Deque path) { - return Stream.concat(path.stream().map(NodePair::getA), Stream.of(path.peekLast().getB())) - .collect(Collectors.toList()); - } - /** - * Tries to find a spanning path starting from node startNode. - * - * Traverses the path in depth-first order. - * - * @param startNode the start node - * @return the spanning path; empty list if no path is found - */ - protected List buildSpanningPath(Node startNode) { - if (startNode != null) { - Deque path = new ArrayDeque<>(); - Set dupCheck = new HashSet<>(); - Deque nextPairs = new ArrayDeque<>(); - nextPairs.addAll(getOutboundPairs(startNode)); - while (!nextPairs.isEmpty()) { - NodePair cur = nextPairs.removeLast(); - if (!dupCheck.contains(cur) && !dupCheck.contains(cur.swap())) { - while (!path.isEmpty() && !path.peekLast().isPredecessorOf(cur)) { - dupCheck.remove(path.removeLast()); - } - path.addLast(cur); - dupCheck.add(cur); - if (isSpanningWay(path)) - return buildPathFromNodePairs(path); - nextPairs.addAll(getOutboundPairs(path.peekLast())); - } - } - } - return Collections.emptyList(); - } - - /** * Tries to find a path through the graph which visits each edge (i.e. * the segment of a way) exactly once. *

Note that duplicated edges are removed first! @@ -287,21 +214,19 @@ */ public List buildSpanningPath() { prepare(); - if (numUndirectedEges > 0 && isConnected()) { - // try to find a path from each "terminal node", i.e. from a - // node which is connected by exactly one undirected edges (or - // two directed edges in opposite direction) to the graph. A - // graph built up from way segments is likely to include such - // nodes, unless the edges build one or more closed rings. - // We order the nodes to start with the best candidates, but - // it might take very long if there is no valid path as we iterate over all nodes - // to find out. - Set nodes = getTerminalNodes(); - nodes = nodes.isEmpty() ? getMostFrequentVisitedNodesFirst() : nodes; - return nodes.stream() - .map(this::buildSpanningPath) - .filter(path -> !path.isEmpty()) - .findFirst().orElse(null); + if (numUndirectedEges > 0) { + int indicator = isEulerian(); + if (indicator > 0) { + List indexes = findpath(adj); + if (indexes.size() == numUndirectedEges + 1) { + List path = new ArrayList<>(indexes.size()); + for (Integer idx : indexes) { + path.add(allNodes.get(idx)); + } + Collections.reverse(path); + return path; + } + } } return null; } @@ -322,59 +247,119 @@ return path == null ? Collections.emptyList() : path; } - /** - * Find out if the graph is connected. - * @return true if it is connected. - */ private boolean isConnected() { - Set nodes = getNodes(); - if (nodes.isEmpty()) + if (allNodes.isEmpty()) return false; - Deque toVisit = new ArrayDeque<>(); - HashSet visited = new HashSet<>(); - toVisit.add(nodes.iterator().next()); + Deque toVisit = new ArrayDeque<>(); + HashSet visited = new HashSet<>(); + toVisit.add(0); while (!toVisit.isEmpty()) { - Node n = toVisit.pop(); + Integer n = toVisit.pop(); if (!visited.contains(n)) { - for (NodePair pair : getConnectedPairs(n)) { - if (n != pair.getA()) - toVisit.addLast(pair.getA()); - if (n != pair.getB()) - toVisit.addLast(pair.getB()); + for (int next : adj[n]) { + if (next != n) { + toVisit.addLast(next); + } } visited.add(n); } } - return nodes.size() == visited.size(); + return allNodes.size() == visited.size(); + } + private void addEdge(int v, int w) { + //Function to add an edge into the graph + adj[v].add(w); // Add w to v's list. + adj[w].add(v); //The graph is undirected + } + /** - * Sort the nodes by number of appearances in the edges. - * @return set of nodes which can be start nodes in a spanning way. + * Check if graph has Eulerian path or Circuit or none of both + * Code taken from https://www.geeksforgeeks.org/eulerian-path-and-circuit/ + * @return 0 if graph is not Eulerian, 1 if there is a Eulerian Path, 2 if there is an Eulerian Circuit */ - private Set getMostFrequentVisitedNodesFirst() { - if (edges.isEmpty()) - return Collections.emptySet(); - // count appearance of nodes in edges - Map counters = new HashMap<>(); - for (NodePair pair : edges) { - Integer c = counters.get(pair.getA()); - counters.put(pair.getA(), c == null ? 1 : c + 1); - c = counters.get(pair.getB()); - counters.put(pair.getB(), c == null ? 1 : c + 1); + private int isEulerian() { + // Check if all vertices are connected + if (!isConnected()) + return 0; + + // Count vertices with odd degree + int odd = 0; + for (int i = 0; i < allNodes.size(); i++) { + if (adj[i].size() % 2 != 0) + odd++; } - // group by counters - TreeMap> sortedMap = new TreeMap<>(Comparator.reverseOrder()); - for (Entry e : counters.entrySet()) { - sortedMap.computeIfAbsent(e.getValue(), x -> new LinkedHashSet<>()).add(e.getKey()); + + // If count is more than 2, then graph is not Eulerian + if (odd > 2) + return 0; + + // If odd count is 2, then semi-eulerian. + // If odd count is 0, then eulerian + // Note that odd count can never be 1 for undirected graph + return (odd == 2) ? 1 : 2; + } + + /** + * Find the Eulerian path. Code taken from https://www.geeksforgeeks.org/eulerian-path-undirected-graph/ + * Original code is contributed by sanjeev2552 + * @param adj adjacency list representation of the graph + * @return List of integers if a path exists, else an empty list + */ + static List findpath(LinkedList[] adj) { + final int n = adj.length; + + // create deep copy of adjacency matrix since the data is modified + @SuppressWarnings("unchecked") + LinkedList[] adjWork = new LinkedList[n]; + for (int i = 0; i < n; i++) { + adjWork[i] = new LinkedList<>(adj[i]); } - LinkedHashSet result = new LinkedHashSet<>(); - for (Entry> e : sortedMap.entrySet()) { - if (e.getKey() > 4 || result.isEmpty()) { - result.addAll(e.getValue()); + + // Find out how many vertex have an odd number of edges + int startPoint = 0; + int numOdd = 0; + for (int i = n - 1; i >= 0; i--) { + if (adjWork[i].size() % 2 != 0) { + numOdd++; + startPoint = i; } } - return Collections.unmodifiableSet(result); + + // If number of vertex with odd number of edges + // is greater than two return "No Solution". + if (numOdd > 2) { + return Collections.emptyList(); + } + + // conditions are met, find the path + Deque stack = new ArrayDeque<>(); + List path = new ArrayList<>(n + 1); + int cur = startPoint; + + // Loop will run while there is element in the stack + // or current edge has some neighbour. + while (!stack.isEmpty() || !adjWork[cur].isEmpty()) { + // If current node has no neighbour + // add it to path and pop stack + // set new current to the popped element + if (adjWork[cur].isEmpty()) { + path.add(cur); + cur = stack.removeLast(); + } else { + // If the current vertex has at least one + // neighbour add the current vertex to stack, + // remove the edge between them and set the + // current to its neighbour. + stack.addLast(cur); + int next = adjWork[cur].removeFirst(); + adjWork[next].removeFirstOccurrence(cur); + cur = next; + } + } + path.add(cur); + return path; } } Index: src/org/openstreetmap/josm/data/osm/NodePair.java =================================================================== --- src/org/openstreetmap/josm/data/osm/NodePair.java (revision 18644) +++ src/org/openstreetmap/josm/data/osm/NodePair.java (working copy) @@ -77,9 +77,9 @@ public String toString() { return new StringBuilder() .append('[') - .append(a.getId()) + .append(a.getUniqueId()) .append(',') - .append(b.getId()) + .append(b.getUniqueId()) .append(']') .toString(); } Index: test/unit/org/openstreetmap/josm/actions/CombineWayActionTest.java =================================================================== --- test/unit/org/openstreetmap/josm/actions/CombineWayActionTest.java (revision 18644) +++ test/unit/org/openstreetmap/josm/actions/CombineWayActionTest.java (working copy) @@ -14,8 +14,8 @@ import java.util.List; import java.util.Set; +import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; -import org.junit.jupiter.api.Test; import org.openstreetmap.josm.TestUtils; import org.openstreetmap.josm.data.osm.DataSet; import org.openstreetmap.josm.data.osm.Node; @@ -134,10 +134,10 @@ Way combined = new Way(0); combined.setNodes(path); assertEquals(expectedLen, combined.getLength(), 1e-7); - List reversedWays = new LinkedList<>(); - List unreversedWays = new LinkedList<>(); - CombineWayAction.detectReversedWays(selection, path, reversedWays, unreversedWays); - assertFalse(reversedWays.isEmpty()); + // List reversedWays = new LinkedList<>(); + // List unreversedWays = new LinkedList<>(); + // CombineWayAction.detectReversedWays(selection, path, reversedWays, unreversedWays); + // assertTrue(reversedWays.isEmpty()); } }