Index: /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/actions/SplitRoundaboutAction.java =================================================================== --- /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/actions/SplitRoundaboutAction.java (revision 33412) +++ /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/actions/SplitRoundaboutAction.java (revision 33413) @@ -7,4 +7,5 @@ import java.util.ArrayList; import java.util.Collection; +import java.util.Collections; import java.util.HashMap; import java.util.HashSet; @@ -21,4 +22,5 @@ import org.openstreetmap.josm.actions.JosmAction; import org.openstreetmap.josm.actions.SplitWayAction; +import org.openstreetmap.josm.actions.SplitWayAction.SplitWayResult; import org.openstreetmap.josm.actions.downloadtasks.DownloadOsmTask; import org.openstreetmap.josm.data.Bounds; @@ -31,4 +33,5 @@ import org.openstreetmap.josm.data.osm.Way; import org.openstreetmap.josm.plugins.pt_assistant.utils.RouteUtils; +import org.openstreetmap.josm.tools.Pair; /** @@ -94,11 +97,13 @@ //save the position of the roundabout inside each relation - Map savedPositions = getSavedPositions(roundabout); + Map> savedPositions = getSavedPositions(roundabout); //split the roundabout on the designed nodes List splitNodes = getSplitNodes(roundabout); - getLayerManager().getEditDataSet().setSelected(splitNodes); - new SplitWayAction().actionPerformed(null); - Collection splitWays = getLayerManager().getEditDataSet().getSelectedWays(); + SplitWayResult result = SplitWayAction.split(getLayerManager().getEditLayer(), + roundabout, splitNodes, Collections.emptyList()); + result.getCommand().executeCommand(); + Collection splitWays = result.getNewWays(); + splitWays.add(result.getOriginalWay()); //update the relations. @@ -106,50 +111,63 @@ } - public void updateRelations(Map savedPositions, + public void updateRelations(Map> savedPositions, List splitNodes, Collection splitWays) { - savedPositions.forEach((r, i) -> { - Way previous = r.getMember(i-1).getWay(); - Way subsequent = r.getMember(i).getWay(); - Node entryNode; - Node exitNode; - - //checking if the previous way enters the roundabout and the - //subsequent exits it - if(splitNodes.contains(previous.lastNode())) - entryNode = previous.lastNode(); - else if(splitNodes.contains(previous.firstNode())) - entryNode = previous.firstNode(); - else - entryNode = null; - - if(splitNodes.contains(subsequent.firstNode())) - exitNode = subsequent.firstNode(); - else if (splitNodes.contains(subsequent.lastNode())) - exitNode = subsequent.lastNode(); - else - exitNode = null; - - //if not, exit - if(entryNode == null || exitNode == null) - return; - - //starting from the entry node, add split ways until the - //exit node is reached - List parents = entryNode.getParentWays(); - parents.removeIf(w -> !w.firstNode().equals(entryNode)); - parents.removeIf(w -> w.equals(previous)); - - Way curr = parents.get(0); - int j = 0; - - while(!curr.lastNode().equals(exitNode)) { - r.addMember(i + j++, new RelationMember(null, curr)); - parents = curr.lastNode().getParentWays(); - parents.remove(curr); - parents.removeIf(w -> !splitWays.contains(w)); - curr = parents.get(0); - } - r.addMember(i + j++, new RelationMember(null, curr)); - }); + Map memberOffset = new HashMap<>(); + savedPositions.forEach((r, positions) -> + positions.forEach(i -> { + + if(!memberOffset.containsKey(r)) + memberOffset.put(r, 0); + int offset = memberOffset.get(r); + + Pair entryExitWays= getEntryExitWays(r, i + offset); + Way entryWay = entryExitWays.a; + Way exitWay = entryExitWays.b; + + //get the entry and exit nodes, exit if not found + Node entryNode = getNodeInCommon(splitNodes, entryWay); + Node exitNode = getNodeInCommon(splitNodes, exitWay); + + if(entryNode == null || exitNode == null) + return; + + //starting from the entry node, add split ways until the + //exit node is reached + List parents = entryNode.getParentWays(); + parents.removeIf(w -> !w.firstNode().equals(entryNode)); + parents.removeIf(w -> w.equals(entryWay)); + + Way curr = parents.get(0); + + while(!curr.lastNode().equals(exitNode)) { + r.addMember(i + offset++, new RelationMember(null, curr)); + parents = curr.lastNode().getParentWays(); + parents.remove(curr); + parents.removeIf(w -> !splitWays.contains(w)); + curr = parents.get(0); + } + r.addMember(i + offset++, new RelationMember(null, curr)); + memberOffset.put(r, offset); + })); + } + + private Node getNodeInCommon(List nodes, Way way) { + if(nodes.contains(way.lastNode())) + return way.lastNode(); + else if(nodes.contains(way.firstNode())) + return way.firstNode(); + + return null; + } + + //given a relation and the position where the roundabout was, it returns + //the entry and exit ways of that occurrence of the roundabout + private Pair getEntryExitWays(Relation r, Integer position) { + + //the ways returned are the one exactly before and after the roundabout + Pair ret = new Pair<>(null, null); + ret.a = r.getMember(position-1).getWay(); + ret.b = r.getMember(position).getWay(); + return ret; } @@ -180,19 +198,24 @@ //save the position of the roundabout inside each public transport route //it is contained in - public Map getSavedPositions(Way roundabout) { - - Map savedPositions = new HashMap<>(); + public Map> getSavedPositions(Way roundabout) { + + Map> savedPositions = new HashMap<>(); List referrers = roundabout.getReferrers(); referrers.removeIf(r -> r.getType() != OsmPrimitiveType.RELATION || !RouteUtils.isTwoDirectionRoute((Relation) r)); + for(OsmPrimitive currPrim : referrers) { Relation curr = (Relation) currPrim; for(int j = 0; j < curr.getMembersCount(); j++) { if(curr.getMember(j).getUniqueId() == roundabout.getUniqueId()) { - savedPositions.put(curr, j); - curr.removeMember(j); - break; + if(!savedPositions.containsKey(curr)) + savedPositions.put(curr, new ArrayList<>()); + List positions = savedPositions.get(curr); + positions.add(j - positions.size()); } } + + if(savedPositions.containsKey(curr)) + curr.removeMembersFor(roundabout); } Index: /applications/editors/josm/plugins/pt_assistant/test/data/roundabout.osm =================================================================== --- /applications/editors/josm/plugins/pt_assistant/test/data/roundabout.osm (revision 33412) +++ /applications/editors/josm/plugins/pt_assistant/test/data/roundabout.osm (revision 33413) @@ -4,4 +4,62 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -1281,4 +1339,132 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -1913,95 +2099,45 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -2012,48 +2148,5 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + @@ -2063,6 +2156,5 @@ - - + @@ -2993,8 +3085,5 @@ - - - - + @@ -3002,11 +3091,5 @@ - - - - - - - + @@ -3014,11 +3097,5 @@ - - - - - - - + Index: /applications/editors/josm/plugins/pt_assistant/test/unit/org/openstreetmap/josm/plugins/pt_assistant/actions/SplitRoundaboutTest.java =================================================================== --- /applications/editors/josm/plugins/pt_assistant/test/unit/org/openstreetmap/josm/plugins/pt_assistant/actions/SplitRoundaboutTest.java (revision 33412) +++ /applications/editors/josm/plugins/pt_assistant/test/unit/org/openstreetmap/josm/plugins/pt_assistant/actions/SplitRoundaboutTest.java (revision 33413) @@ -41,5 +41,5 @@ private OsmDataLayer layer; private SplitRoundaboutAction action; - private Way r1, r2, r3; + private Way r1, r2, r3, r4; @Before @@ -54,13 +54,14 @@ r2 = (Way) ds.getPrimitiveById(new SimplePrimitiveId(205833435L, OsmPrimitiveType.WAY)); r3 = (Way) ds.getPrimitiveById(new SimplePrimitiveId(25739002L, OsmPrimitiveType.WAY)); + r4 = (Way) ds.getPrimitives(p -> p.hasTag("name", "r4")).iterator().next(); } private Collection splitWay(Way w) { - Map savedPositions = action.getSavedPositions(w); + Map> savedPositions = action.getSavedPositions(w); List splitNodes = action.getSplitNodes(w); - assertEquals(4, splitNodes.size()); SplitWayResult result = SplitWayAction.split(layer, w, splitNodes, Collections.emptyList()); result.getCommand().executeCommand(); Collection splitWays = result.getNewWays(); + splitWays.add(result.getOriginalWay()); action.updateRelations(savedPositions, splitNodes, splitWays); return splitWays; @@ -69,6 +70,8 @@ @Test public void test1() { - splitWay(r1).forEach(w -> { - if (w.firstNode().getUniqueId() == 267843779L && w.lastNode().getUniqueId() == 2968718407L) + Collection sw1 = splitWay(r1); + assertEquals(4, sw1.size()); + sw1.forEach(w -> { + if (w.firstNode().getUniqueId() == 267843779L && w.lastNode().getUniqueId() == 2968718407L) assertEquals(w.getReferrers().size(), 5); else if (w.firstNode().getUniqueId() == 2968718407L && w.lastNode().getUniqueId() == 2383688231L) @@ -85,5 +88,7 @@ @Test public void test2() { - splitWay(r2).forEach(w -> { + Collection sw2 = splitWay(r2); + assertEquals(4, sw2.size()); + sw2.forEach(w -> { if(w.firstNode().getUniqueId() == 2158181809L && w.lastNode().getUniqueId() == 2158181798L) assertEquals(w.getReferrers().size(), 8); @@ -101,5 +106,7 @@ @Test public void test3() { - splitWay(r3).forEach(w -> { + Collection sw3 = splitWay(r3); + assertEquals(4, sw3.size()); + sw3.forEach(w -> { if(w.firstNode().getUniqueId() == 280697532L && w.lastNode().getUniqueId() == 280697452L) assertEquals(w.getReferrers().size(), 0); @@ -114,3 +121,44 @@ }); } + + @Test + public void test4() { + Collection sw4 = splitWay(r4); + assertEquals(10, sw4.size()); + Node entry11 = (Node) ds.getPrimitives(p -> p.hasTag("name", "nentry1-1")).iterator().next(); + Node exit11 = (Node) ds.getPrimitives(p -> p.hasTag("name", "nexit1-1")).iterator().next(); + Node entry12 = (Node) ds.getPrimitives(p -> p.hasTag("name", "nentry1-2")).iterator().next(); + Node exit12 = (Node) ds.getPrimitives(p -> p.hasTag("name", "nexit1-2")).iterator().next(); + Node entry21 = (Node) ds.getPrimitives(p -> p.hasTag("name", "nentry2-1")).iterator().next(); + Node exit21 = (Node) ds.getPrimitives(p -> p.hasTag("name", "nexit2-1")).iterator().next(); + Node entry22 = (Node) ds.getPrimitives(p -> p.hasTag("name", "nentry2-2")).iterator().next(); + Node exit22 = (Node) ds.getPrimitives(p -> p.hasTag("name", "nexit2-2")).iterator().next(); + Node entry3 = (Node) ds.getPrimitives(p -> p.hasTag("name", "nentry3")).iterator().next(); + Node exit3 = (Node) ds.getPrimitives(p -> p.hasTag("name", "nexit3")).iterator().next(); + + sw4.forEach(w -> { + if(w.firstNode().equals(entry11) && w.lastNode().equals(exit22)) + assertEquals(2, w.getReferrers().size()); + else if(w.firstNode().equals(exit22) && w.lastNode().equals(entry21)) + assertEquals(1, w.getReferrers().size()); + else if(w.firstNode().equals(entry21) && w.lastNode().equals(exit11)) + assertEquals(2, w.getReferrers().size()); + else if(w.firstNode().equals(exit11) && w.lastNode().equals(entry12)) + assertEquals(1, w.getReferrers().size()); + else if(w.firstNode().equals(entry12) && w.lastNode().equals(entry3)) + assertEquals(2, w.getReferrers().size()); + else if(w.firstNode().equals(entry3) && w.lastNode().equals(exit21)) + assertEquals(3, w.getReferrers().size()); + else if(w.firstNode().equals(exit21) && w.lastNode().equals(entry22)) + assertEquals(2, w.getReferrers().size()); + else if(w.firstNode().equals(entry22) && w.lastNode().equals(exit3)) + assertEquals(3, w.getReferrers().size()); + else if(w.firstNode().equals(exit3) && w.lastNode().equals(exit12)) + assertEquals(2, w.getReferrers().size()); + else if(w.firstNode().equals(exit12) && w.lastNode().equals(entry11)) + assertEquals(1, w.getReferrers().size()); + else + fail(); + }); + } }