Index: /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/data/PTRouteDataManager.java =================================================================== --- /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/data/PTRouteDataManager.java (revision 32746) +++ /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/data/PTRouteDataManager.java (revision 32747) @@ -122,5 +122,6 @@ /** - * Assigns the given way to a PTWay of this route relation. + * Assigns the given way to a PTWay of this route relation. If multiple + * PTWays contain the same inputWay, the first found PTWay is returned. * * @param inputWay Index: /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/data/PTRouteSegment.java =================================================================== --- /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/data/PTRouteSegment.java (revision 32746) +++ /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/data/PTRouteSegment.java (revision 32747) @@ -19,4 +19,5 @@ private PTStop lastStop; private List ptways; + private List> fixVariants; public PTRouteSegment(PTStop firstStop, PTStop lastStop, List ways) { @@ -25,14 +26,14 @@ this.ptways = new ArrayList<>(ways.size()); ptways.addAll(ways); - } - - public PTRouteSegment(PTStop firstStop, PTStop lastStop) { - this.firstStop = firstStop; - this.lastStop = lastStop; - this.ptways = new ArrayList<>(); + fixVariants = new ArrayList<>(); } public List getPTWays() { return this.ptways; + } + + public void setPTWays(List ptwayList) { + this.ptways = ptwayList; + this.fixVariants.clear(); } @@ -45,6 +46,25 @@ } + public PTWay getFirstPTWay() { + if (ptways.isEmpty()) { + return null; + } + return ptways.get(0); + } + public PTWay getLastPTWay() { + if (ptways.isEmpty()) { + return null; + } + return ptways.get(ptways.size() - 1); + } + public void addFixVariant(List list) { + this.fixVariants.add(list); + } + + public List> getFixVariants() { + return this.fixVariants; + } Index: /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/data/PTWay.java =================================================================== --- /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/data/PTWay.java (revision 32746) +++ /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/data/PTWay.java (revision 32747) @@ -123,5 +123,5 @@ List ways = this.getWays(); for (Way way: ways) { - if (way.hasTag("junction", "roundabout") && way.firstNode() == way.lastNode()) { + if (way.firstNode() == way.lastNode()) { return true; } @@ -129,4 +129,18 @@ return false; } + + public boolean startsWithUnsplitRoundabout() { + if (this.ways.get(0).firstNode() == this.ways.get(0).lastNode()) { + return true; + } + return false; + } + + public boolean endsWithUnsplitRoundabout() { + if (this.ways.get(this.ways.size() - 1).firstNode() == this.ways.get(this.ways.size()-1).lastNode()) { + return true; + } + return false; + } } Index: /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/PTAssistantValidatorTest.java =================================================================== --- /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/PTAssistantValidatorTest.java (revision 32746) +++ /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/PTAssistantValidatorTest.java (revision 32747) @@ -320,4 +320,5 @@ if (!sortingErrorFound) { segmentChecker.performStopByStopTest(); + segmentChecker.findFixes(); } Index: /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/SegmentChecker.java =================================================================== --- /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/SegmentChecker.java (revision 32746) +++ /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/SegmentChecker.java (revision 32747) @@ -6,4 +6,6 @@ import java.util.HashMap; import java.util.List; + +import javax.swing.JOptionPane; import org.openstreetmap.josm.command.ChangeCommand; @@ -47,9 +49,9 @@ private StopToWayAssigner assigner; - /* - * Stores reference that shows in which direction the segment checker is - * moving - */ - private Node firstNodeOfRouteSegmentInDirectionOfTravel; + private List unusedWays = new ArrayList<>(); + + private HashMap erroneousPTWays = new HashMap<>(); + + private HashMap firstNodeOfErroneousPTWay = new HashMap<>(); public SegmentChecker(Relation relation, Test test) { @@ -70,4 +72,6 @@ this.assigner = new StopToWayAssigner(manager.getPTWays()); + + unusedWays.addAll(manager.getPTWays()); } @@ -241,6 +245,4 @@ for (int i = 1; i < manager.getPTStopCount(); i++) { -// this.firstNodeOfRouteSegmentInDirectionOfTravel = null; - PTStop startStop = manager.getPTStops().get(i - 1); PTStop endStop = manager.getPTStops().get(i); @@ -254,7 +256,6 @@ List segmentWays = manager.getPTWaysBetween(startWay, endWay); - Node testNode = findFirstNodeOfRouteSegmentInDirectionOfTravel( - segmentWays.get(0)); - if (testNode == null) { + Node firstNode = findFirstNodeOfRouteSegmentInDirectionOfTravel(segmentWays.get(0)); + if (firstNode == null) { // check if this error has just been reported: if (!this.errors.isEmpty() && this.errors.get(this.errors.size() - 1).getHighlighted().size() == 1 @@ -272,13 +273,16 @@ PTRouteSegment routeSegment = new PTRouteSegment(startStop, endStop, segmentWays); wrongSegments.put(e, routeSegment); + erroneousPTWays.put(e, manager.getPTWay(startWay)); + firstNodeOfErroneousPTWay.put(e, null); } continue; } - boolean sortingCorrect = existingWaySortingIsCorrect(segmentWays.get(0), - testNode, segmentWays.get(segmentWays.size() - 1)); + boolean sortingCorrect = existingWaySortingIsCorrect(segmentWays.get(0), firstNode, + segmentWays.get(segmentWays.size() - 1)); if (sortingCorrect) { PTRouteSegment routeSegment = new PTRouteSegment(startStop, endStop, segmentWays); correctSegments.add(routeSegment); + unusedWays.removeAll(segmentWays); } else { PTRouteSegment routeSegment = new PTRouteSegment(startStop, endStop, segmentWays); @@ -430,4 +434,5 @@ PTAssistantValidatorTest.ERROR_CODE_STOP_BY_STOP, primitives, highlighted); this.errors.add(e); + erroneousPTWays.put(e, current); return false; } @@ -439,6 +444,5 @@ currentNode = getOppositeEndNode(current, currentNode); - List nextWaysInDirectionOfTravel = this.findNextPTWaysInDirectionOfTravel(current, - currentNode); + List nextWaysInDirectionOfTravel = this.findNextPTWaysInDirectionOfTravel(current, currentNode); if (!nextWaysInDirectionOfTravel.contains(nextPTWayAccortingToExistingSorting)) { @@ -557,8 +561,5 @@ return true; } - if (isFixableBySegmentSorting(testError)) { - return true; - } - if (isFixableByRemovingWays()) { + if (isFixableBySortingAndRemoval(testError)) { return true; } @@ -587,12 +588,10 @@ } - private static boolean isFixableBySegmentSorting(TestError testError) { + private static boolean isFixableBySortingAndRemoval(TestError testError) { PTRouteSegment wrongSegment = wrongSegments.get(testError); - - return false; - } - - private static boolean isFixableByRemovingWays() { - // TODO + List> fixVariants = wrongSegment.getFixVariants(); + if (!fixVariants.isEmpty()) { + return true; + } return false; } @@ -603,7 +602,88 @@ } + protected void findFixes() { + for (TestError error : wrongSegments.keySet()) { + findFix(error); + } + } + + /** + * This method assumes that the first and the second ways of the route + * segment are correctly connected. If they are not, the error will be + * marked as not fixable. + * + * @param testError + */ + private void findFix(TestError testError) { + + PTRouteSegment wrongSegment = wrongSegments.get(testError); + PTWay startPTWay = wrongSegment.getFirstPTWay(); + PTWay endPTWay = wrongSegment.getLastPTWay(); + + Node previousNode = findFirstNodeOfRouteSegmentInDirectionOfTravel(startPTWay); + if (previousNode == null) { + // TODO: sort route ways + return; + } + + List> initialFixes = new ArrayList<>(); + List initialFix = new ArrayList<>(); + initialFix.add(startPTWay); + initialFixes.add(initialFix); + List fix = findWaysForFix(initialFixes, initialFix, previousNode, endPTWay).get(0); + + if (!fix.isEmpty() && fix.get(fix.size() - 1).equals(endPTWay)) { + wrongSegment.addFixVariant(fix); + } + + } + + /** + * + * @param allFixes + * @param currentFix + * @param previousNode + * @param endWay + * @return + */ + private List> findWaysForFix (List> allFixes, List currentFix, Node previousNode, + PTWay endWay) { + + PTWay currentWay = currentFix.get(currentFix.size() - 1); + Node nextNode = getOppositeEndNode(currentWay, previousNode); + + List potentialNextWays = this.findNextPTWaysInDirectionOfTravel(currentWay, nextNode); + List nextWays = new ArrayList<>(); + for (PTWay potentianNextWay : potentialNextWays) { + if (unusedWays.contains(potentianNextWay)) { + nextWays.add(potentianNextWay); + } + } + + if (!nextWays.isEmpty()) { + currentFix.add(nextWays.get(0)); + if (!nextWays.get(0).equals(endWay)) { + allFixes = findWaysForFix(allFixes, currentFix, nextNode, endWay); + } + } + +// if (nextWays.size() > 1) { +// for (int i = 1; i < nextWays.size(); i++) { +// List newList = new ArrayList<>(); +// newList.addAll(currentFix); +// newList.add(nextWays.get(i)); +// allFixes.add(newList); +// // TODO: go on +// } +// } + + return allFixes; + } + protected static Command fixError(TestError testError) { PTRouteSegment wrongSegment = wrongSegments.get(testError); + + // 1) try to fix by using the correct segment: PTRouteSegment correctSegment = null; // TODO: now just the first correctSegment is taken over. Change that @@ -653,6 +733,4 @@ for (int i = 0; i < waysOfOriginalRelation.size(); i++) { if (waysOfOriginalRelation.get(i).getWay() == wrongSegment.getPTWays().get(0).getWays().get(0)) { - // if (waysOfOriginalRelation.get(i) == - // wrongSegment.getPTWays().get(0)) { for (PTWay ptway : correctSegment.getPTWays()) { if (ptway.getRole().equals("forward") || ptway.getRole().equals("backward")) { @@ -678,4 +756,67 @@ ChangeCommand changeCommand = new ChangeCommand(originalRelation, modifiedRelation); return changeCommand; + + } else if (!wrongSegment.getFixVariants().isEmpty()) { + // 2) try to fix by using the sort & remove method: + // TODO: ask user if the change should be undertaken + Relation originalRelation = (Relation) testError.getPrimitives().iterator().next(); + Relation modifiedRelation = new Relation(originalRelation); + List originalRelationMembers = originalRelation.getMembers(); + List modifiedRelationMembers = new ArrayList<>(); + + // copy stops first: + for (RelationMember rm : originalRelationMembers) { + if (RouteUtils.isPTStop(rm)) { + if (rm.getRole().equals("stop_position")) { + if (rm.getType().equals(OsmPrimitiveType.NODE)) { + RelationMember newMember = new RelationMember("stop", rm.getNode()); + modifiedRelationMembers.add(newMember); + } else { // if it is a way: + RelationMember newMember = new RelationMember("stop", rm.getWay()); + modifiedRelationMembers.add(newMember); + } + } else { + // if the relation member does not have the role + // "stop_position": + modifiedRelationMembers.add(rm); + } + } + } + + // copy PTWays next: + List waysOfOriginalRelation = new ArrayList<>(); + for (RelationMember rm : originalRelation.getMembers()) { + if (RouteUtils.isPTWay(rm)) { + waysOfOriginalRelation.add(rm); + } + } + + for (int i = 0; i < waysOfOriginalRelation.size(); i++) { + if (waysOfOriginalRelation.get(i).getWay() == wrongSegment.getPTWays().get(0).getWays().get(0)) { + for (PTWay ptway : wrongSegment.getFixVariants().get(0)) { + if (ptway.getRole().equals("forward") || ptway.getRole().equals("backward")) { + modifiedRelationMembers.add(new RelationMember("", ptway.getMember())); + } else { + modifiedRelationMembers.add(ptway); + } + } + i = i + wrongSegment.getPTWays().size() - 1; + } else { + if (waysOfOriginalRelation.get(i).getRole().equals("forward") + || waysOfOriginalRelation.get(i).getRole().equals("backward")) { + modifiedRelationMembers.add(new RelationMember("", waysOfOriginalRelation.get(i).getMember())); + } else { + modifiedRelationMembers.add(waysOfOriginalRelation.get(i)); + } + } + } + modifiedRelation.setMembers(modifiedRelationMembers); + // TODO: change the data model too + wrongSegments.remove(testError); + wrongSegment.setPTWays(wrongSegment.getFixVariants().get(0)); + correctSegments.add(wrongSegment); + ChangeCommand changeCommand = new ChangeCommand(originalRelation, modifiedRelation); + return changeCommand; + }