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 32775) +++ applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/data/PTRouteSegment.java (revision 32776) @@ -3,4 +3,6 @@ import java.util.ArrayList; import java.util.List; + +import org.openstreetmap.josm.data.osm.Way; /** @@ -20,5 +22,5 @@ private List ptways; private List> fixVariants; - + public PTRouteSegment(PTStop firstStop, PTStop lastStop, List ways) { this.firstStop = firstStop; @@ -28,22 +30,22 @@ fixVariants = new ArrayList<>(); } - + public List getPTWays() { return this.ptways; } - + public void setPTWays(List ptwayList) { this.ptways = ptwayList; this.fixVariants.clear(); } - + public PTStop getFirstStop() { return this.firstStop; } - + public PTStop getLastStop() { return this.lastStop; } - + public PTWay getFirstPTWay() { if (ptways.isEmpty()) { @@ -52,5 +54,5 @@ return ptways.get(0); } - + public PTWay getLastPTWay() { if (ptways.isEmpty()) { @@ -59,13 +61,40 @@ return ptways.get(ptways.size() - 1); } - + public void addFixVariant(List list) { this.fixVariants.add(list); } - + public List> getFixVariants() { return this.fixVariants; } - + + /** + * Checks if this and the other route segments are equal + * + * @param other + * @return + */ + public boolean equalsRouteSegment(PTRouteSegment other) { + List thisWays = new ArrayList<>(); + for (PTWay ptway : this.ptways) { + thisWays.addAll(ptway.getWays()); + } + List otherWays = new ArrayList<>(); + for (PTWay ptway : other.getPTWays()) { + otherWays.addAll(ptway.getWays()); + } + if (thisWays.size() != otherWays.size()) { + return false; + } + + for (int i = 0; i < thisWays.size(); i++) { + if (thisWays.get(i) != otherWays.get(i)) { + return false; + } + } + + return true; + } } Index: applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/gui/PTAssistantLayer.java =================================================================== --- applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/gui/PTAssistantLayer.java (revision 32775) +++ applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/gui/PTAssistantLayer.java (revision 32776) @@ -8,4 +8,5 @@ import java.util.ArrayList; import java.util.Collection; +import java.util.HashMap; import java.util.List; @@ -32,4 +33,5 @@ import org.openstreetmap.josm.gui.layer.LayerPositionStrategy; import org.openstreetmap.josm.gui.layer.OsmDataLayer; +import org.openstreetmap.josm.plugins.pt_assistant.data.PTWay; import org.openstreetmap.josm.plugins.pt_assistant.utils.RouteUtils; import org.openstreetmap.josm.tools.ImageProvider; @@ -41,4 +43,5 @@ private List primitives = new ArrayList<>(); private PTAssistantPaintVisitor paintVisitor; + private HashMap> fixVariants = new HashMap<>(); private PTAssistantLayer() { @@ -64,4 +67,40 @@ this.primitives.clear(); } + + public void clearFixVariants() { + fixVariants.clear(); + Main.map.mapView.repaint(); + } + + /** + * Adds fix variants to be displayed in the pt_assistant layer + * @param fixVariants + */ + public void addFixVariants(List> fixVariants) { + char alphabet = 'A'; + for (int i = 0; i < fixVariants.size(); i++) { + if (i < 5) { + List fixVariant = fixVariants.get(0); + this.fixVariants.put(alphabet, fixVariant); + alphabet++; + } + } + +// for (List fixVariant: fixVariants) { +// +// this.fixVariants.put(alphabet, fixVariant); +// alphabet++; +// } + } + + /** + * Returns fix variant (represented by a list of PTWays) that corresponds to the given character. + * @param c + * @return + */ + public List getFixVariant(char c) { + return this.fixVariants.get(Character.toUpperCase(c)); + } + @Override @@ -72,6 +111,7 @@ for (OsmPrimitive primitive : primitives) { paintVisitor.visit(primitive); - - } + } + + paintVisitor.visitFixVariants(this.fixVariants); } @@ -199,4 +239,6 @@ paintVisitor.visit(primitive); } + + paintVisitor.visitFixVariants(this.fixVariants); Main.map.mapView.repaint(); Index: applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/gui/PTAssistantPaintVisitor.java =================================================================== --- applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/gui/PTAssistantPaintVisitor.java (revision 32775) +++ applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/gui/PTAssistantPaintVisitor.java (revision 32776) @@ -11,4 +11,5 @@ import java.util.List; +import org.openstreetmap.josm.Main; import org.openstreetmap.josm.data.osm.Node; import org.openstreetmap.josm.data.osm.OsmPrimitive; @@ -19,5 +20,7 @@ import org.openstreetmap.josm.data.validation.PaintVisitor; import org.openstreetmap.josm.gui.MapView; +import org.openstreetmap.josm.plugins.pt_assistant.data.PTWay; import org.openstreetmap.josm.plugins.pt_assistant.utils.RouteUtils; +import org.openstreetmap.josm.tools.Pair; public class PTAssistantPaintVisitor extends PaintVisitor { @@ -85,5 +88,9 @@ stopOrderMap.put(rm.getUniqueId(), label); - drawStopLabel(rm.getMember(), label); + try { + drawStopLabel(rm.getMember(), label); + } catch (NullPointerException ex) { + // do nothing + } stopCount++; } @@ -170,5 +177,10 @@ protected void drawSegment(Node n1, Node n2, Color color, int oneway) { if (n1.isDrawable() && n2.isDrawable() && isSegmentVisible(n1, n2)) { - drawSegment(mv.getPoint(n1), mv.getPoint(n2), color, oneway); + try { + drawSegment(mv.getPoint(n1), mv.getPoint(n2), color, oneway); + } catch (NullPointerException ex) { + // do nothing + } + } } @@ -281,8 +293,10 @@ Point p = mv.getPoint(n); - g.setColor(Color.WHITE); - Font stringFont = new Font("SansSerif", Font.PLAIN, 24); - g.setFont(stringFont); - g.drawString(label, p.x + 20, p.y - 20); + if (label != null && !label.equals("")) { + g.setColor(Color.WHITE); + Font stringFont = new Font("SansSerif", Font.PLAIN, 24); + g.setFont(stringFont); + g.drawString(label, p.x + 20, p.y - 20); + } // draw the ref values of all parent routes: @@ -382,3 +396,51 @@ } + /** + * + * @param fixVariants + */ + protected void visitFixVariants(HashMap> fixVariants) { + Color[] colors = { new Color(255, 0, 0, 150), new Color(0, 255, 0, 150), new Color(0, 0, 255, 150), + new Color(255, 255, 0, 150), new Color(0, 255, 255, 150) }; + + int colorIndex = 0; + + double letterX = Main.map.mapView.getBounds().getMinX() + 20; + double letterY = Main.map.mapView.getBounds().getMinY() + 100; + + for (Character c : fixVariants.keySet()) { + if (fixVariants.get(c) != null) { + drawFixVariant(fixVariants.get(c), colors[colorIndex % 5]); + drawFixVariantLetter(fixVariants.get(c), c, colors[colorIndex%5], letterX, letterY); + colorIndex++; + letterY = letterY + 60; + } + } + + + } + + /** + * + * @param fixVariant + * @param color + */ + private void drawFixVariant(List fixVariant, Color color) { + for (PTWay ptway : fixVariant) { + for (Way way : ptway.getWays()) { + for (Pair nodePair : way.getNodePairs(false)) { + drawSegment(nodePair.a, nodePair.b, color, 0); + } + } + } + } + + private void drawFixVariantLetter(List fixVariant, Character letter, Color color, double letterX, double letterY) { + g.setColor(color); + Font stringFont = new Font("SansSerif", Font.PLAIN, 50); + g.setFont(stringFont); + g.drawString(letter.toString(), (int) letterX, (int) letterY); + g.drawString(letter.toString(), (int) letterX, (int) letterY); + } + } 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 32775) +++ applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/PTAssistantValidatorTest.java (revision 32776) @@ -419,5 +419,4 @@ // run fix task asynchronously FixTask fixTask = new FixTask(testErrors); - // Main.worker.submit(fixTask); Thread t = new Thread(fixTask); @@ -431,4 +430,16 @@ } + } + + public void addFixVariants(List> fixVariants) { + layer.addFixVariants(fixVariants); + } + + public void clearFixVariants() { + layer.clearFixVariants(); + } + + public List getFixVariant(Character c) { + return layer.getFixVariant(c); } 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 32775) +++ applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/SegmentChecker.java (revision 32776) @@ -3,12 +3,18 @@ import static org.openstreetmap.josm.tools.I18n.tr; +import java.lang.reflect.InvocationTargetException; import java.util.ArrayList; +import java.util.Collection; import java.util.HashMap; import java.util.List; import javax.swing.JOptionPane; - +import javax.swing.SwingUtilities; + +import org.openstreetmap.josm.Main; +import org.openstreetmap.josm.actions.AutoScaleAction; import org.openstreetmap.josm.command.ChangeCommand; import org.openstreetmap.josm.command.Command; +import org.openstreetmap.josm.command.SelectCommand; import org.openstreetmap.josm.data.coor.LatLon; import org.openstreetmap.josm.data.osm.Node; @@ -21,8 +27,12 @@ import org.openstreetmap.josm.data.validation.Test; import org.openstreetmap.josm.data.validation.TestError; +import org.openstreetmap.josm.gui.dialogs.relation.GenericRelationEditor; +import org.openstreetmap.josm.gui.dialogs.relation.RelationEditor; +import org.openstreetmap.josm.gui.layer.OsmDataLayer; import org.openstreetmap.josm.plugins.pt_assistant.data.PTRouteDataManager; import org.openstreetmap.josm.plugins.pt_assistant.data.PTRouteSegment; import org.openstreetmap.josm.plugins.pt_assistant.data.PTStop; import org.openstreetmap.josm.plugins.pt_assistant.data.PTWay; +import org.openstreetmap.josm.plugins.pt_assistant.gui.PTAssistantLayer; import org.openstreetmap.josm.plugins.pt_assistant.utils.RouteUtils; import org.openstreetmap.josm.plugins.pt_assistant.utils.StopToWayAssigner; @@ -95,4 +105,9 @@ */ public static void addCorrectSegment(PTRouteSegment segment) { + for (PTRouteSegment correctSegment : correctSegments) { + if (correctSegment.equalsRouteSegment(segment)) { + return; + } + } correctSegments.add(segment); } @@ -283,5 +298,5 @@ if (sortingCorrect) { PTRouteSegment routeSegment = new PTRouteSegment(startStop, endStop, segmentWays); - correctSegments.add(routeSegment); + addCorrectSegment(routeSegment); unusedWays.removeAll(segmentWays); } else { @@ -452,5 +467,4 @@ highlighted.addAll(current.getWays()); - highlighted.add(currentNode); TestError e = new TestError(this.test, Severity.WARNING, tr("PT: Problem in the route segment"), @@ -558,13 +572,5 @@ if (testError.getCode() == PTAssistantValidatorTest.ERROR_CODE_STOP_BY_STOP) { - if (isFixableByUsingCorrectSegment(testError)) { - return true; - } - if (isFixableBySortingAndRemoval(testError)) { - return true; - } - if (isFixableBySimpleRouting()) { - return true; - } + return true; } @@ -573,4 +579,5 @@ } + @SuppressWarnings("unused") private static boolean isFixableByUsingCorrectSegment(TestError testError) { PTRouteSegment wrongSegment = wrongSegments.get(testError); @@ -588,4 +595,5 @@ } + @SuppressWarnings("unused") private static boolean isFixableBySortingAndRemoval(TestError testError) { PTRouteSegment wrongSegment = wrongSegments.get(testError); @@ -597,9 +605,4 @@ } - private static boolean isFixableBySimpleRouting() { - // TODO - return false; - } - protected void findFixes() { for (TestError error : wrongSegments.keySet()) { @@ -638,5 +641,4 @@ } } - } @@ -644,4 +646,5 @@ /** * Recursive method to parse the route segment + * * @param allFixes * @param currentFix @@ -657,5 +660,5 @@ List nextWays = this.findNextPTWaysInDirectionOfTravel(currentWay, nextNode); - + if (nextWays.size() > 1) { for (int i = 1; i < nextWays.size(); i++) { @@ -678,9 +681,14 @@ } - - return allFixes; } + /** + * Fixes the error by first searching in the list of correct segments and + * then trying to sort and remove existing route relation members + * + * @param testError + * @return + */ protected static Command fixError(TestError testError) { @@ -688,17 +696,47 @@ // 1) try to fix by using the correct segment: - PTRouteSegment correctSegment = null; - // TODO: now just the first correctSegment is taken over. Change that - // the segment is selected. + List correctSegmentsForThisError = new ArrayList<>(); for (PTRouteSegment segment : correctSegments) { if (wrongSegment.getFirstStop().equalsStop(segment.getFirstStop()) && wrongSegment.getLastStop().equalsStop(segment.getLastStop())) { - correctSegment = segment; - break; - } - } - - if (correctSegment != null) { - // TODO: ask user if the change should be undertaken + correctSegmentsForThisError.add(segment); + } + } + + if (!correctSegmentsForThisError.isEmpty()) { + + List fix = null; + + if (correctSegmentsForThisError.size() > 1) { + fix = displayCorrectSegmentVariants(correctSegmentsForThisError, testError); + if (fix == null) { + return null; + } + } else { + fix = correctSegmentsForThisError.get(0).getPTWays(); + final Collection waysToZoom = new ArrayList<>(); + for (Object highlightedPrimitive: testError.getHighlighted()) { + waysToZoom.add((OsmPrimitive)highlightedPrimitive); + } + if (SwingUtilities.isEventDispatchThread()) { + AutoScaleAction.zoomTo(waysToZoom); + } else { + SwingUtilities.invokeLater(new Runnable() { + @Override + public void run() { + AutoScaleAction.zoomTo(waysToZoom); + } + }); + } + synchronized(SegmentChecker.class) { + try { + SegmentChecker.class.wait(2000); + } catch (InterruptedException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + } + Relation originalRelation = (Relation) testError.getPrimitives().iterator().next(); Relation modifiedRelation = new Relation(originalRelation); @@ -735,5 +773,5 @@ for (int i = 0; i < waysOfOriginalRelation.size(); i++) { if (waysOfOriginalRelation.get(i).getWay() == wrongSegment.getPTWays().get(0).getWays().get(0)) { - for (PTWay ptway : correctSegment.getPTWays()) { + for (PTWay ptway : fix) { if (ptway.getRole().equals("forward") || ptway.getRole().equals("backward")) { modifiedRelationMembers.add(new RelationMember("", ptway.getMember())); @@ -760,5 +798,38 @@ } else if (!wrongSegment.getFixVariants().isEmpty()) { - + + List fix = null; + + if (wrongSegment.getFixVariants().size() > 1) { + fix = displayFixVariants(wrongSegment.getFixVariants(), testError); + if (fix == null) { + return null; + } + } else { + fix = wrongSegment.getFixVariants().get(0); + final Collection waysToZoom = new ArrayList<>(); + for (Object highlightedPrimitive: testError.getHighlighted()) { + waysToZoom.add((OsmPrimitive)highlightedPrimitive); + } + if (SwingUtilities.isEventDispatchThread()) { + AutoScaleAction.zoomTo(waysToZoom); + } else { + SwingUtilities.invokeLater(new Runnable() { + @Override + public void run() { + AutoScaleAction.zoomTo(waysToZoom); + } + }); + } + synchronized(SegmentChecker.class) { + try { + SegmentChecker.class.wait(2000); + } catch (InterruptedException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + } + // 2) try to fix by using the sort & remove method: // TODO: ask user if the change should be undertaken @@ -797,5 +868,5 @@ 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)) { // FIXME + for (PTWay ptway : fix) { if (ptway.getRole().equals("forward") || ptway.getRole().equals("backward")) { modifiedRelationMembers.add(new RelationMember("", ptway.getMember())); @@ -814,10 +885,10 @@ } } - + modifiedRelation.setMembers(modifiedRelationMembers); // TODO: change the data model too wrongSegments.remove(testError); wrongSegment.setPTWays(wrongSegment.getFixVariants().get(0)); - correctSegments.add(wrongSegment); + addCorrectSegment(wrongSegment); ChangeCommand changeCommand = new ChangeCommand(originalRelation, modifiedRelation); return changeCommand; @@ -825,5 +896,187 @@ } + // if there is no fix: + return fixErrorByZooming(testError); + + } + + /** + * + * @param segments + */ + private static List displayCorrectSegmentVariants(List segments, TestError testError) { + List> fixVariantList = new ArrayList<>(); + for (PTRouteSegment segment : segments) { + fixVariantList.add(segment.getPTWays()); + } + return displayFixVariants(fixVariantList, testError); + } + + /** + * + * @param fixVariants + */ + private static List displayFixVariants(List> fixVariants, TestError testError) { + // find the letters of the fix variants: + char alphabet = 'A'; + List allowedCharacters = new ArrayList<>(); + for (int i = 0; i < fixVariants.size(); i++) { + allowedCharacters.add(alphabet); + alphabet++; + } + + // zoom to problem: + final Collection waysToZoom = new ArrayList<>(); +// for (List fix : fixVariants) { +// for (PTWay ptway : fix) { +// waysToZoom.addAll(ptway.getWays()); +// } +// } + for (Object highlightedPrimitive: testError.getHighlighted()) { + waysToZoom.add((OsmPrimitive)highlightedPrimitive); + } + if (SwingUtilities.isEventDispatchThread()) { + AutoScaleAction.zoomTo(waysToZoom); + } else { + SwingUtilities.invokeLater(new Runnable() { + @Override + public void run() { + AutoScaleAction.zoomTo(waysToZoom); + } + }); + } + + // display the fix variants: + PTAssistantValidatorTest test = (PTAssistantValidatorTest) testError.getTester(); + test.addFixVariants(fixVariants); + PTAssistantLayer.getLayer().repaint((Relation) testError.getPrimitives().iterator().next()); + + // get user input: + Character userInput = getUserInput(allowedCharacters); + if (userInput == null) { + test.clearFixVariants(); + return null; + } + List selectedFix = test.getFixVariant(userInput); + test.clearFixVariants(); + return selectedFix; + } + + /** + * Asks user to choose the fix variant and returns the choice + * + * @param allowedCharacters + * @return + */ + private static Character getUserInput(List allowedCharacters) { + final String[] userInput = { "" }; + + while (userInput[0] == null || userInput[0].length() != 1 || userInput[0].equals("") + || !allowedCharacters.contains(userInput[0].toUpperCase().toCharArray()[0])) { + if (SwingUtilities.isEventDispatchThread()) { + + userInput[0] = JOptionPane.showInputDialog("Enter a letter to select the fix variant: "); + + } else { + + try { + SwingUtilities.invokeAndWait(new Runnable() { + @Override + public void run() { + + userInput[0] = JOptionPane.showInputDialog("Enter a letter to select the fix variant: "); + + } + }); + } catch (InvocationTargetException | InterruptedException e1) { + break; + } + + } + if (userInput[0] == null) { + break; + } + } + + if (userInput[0] == null) { + return null; + } + return userInput[0].toCharArray()[0]; + + } + + /** + * + * @param testError + * @return + */ + protected static Command fixErrorByZooming(TestError testError) { + + if (testError.getCode() != PTAssistantValidatorTest.ERROR_CODE_STOP_BY_STOP) { + return null; + } + + Collection primitives = testError.getPrimitives(); + Relation originalRelation = (Relation) primitives.iterator().next(); + ArrayList primitivesToZoom = new ArrayList<>(); + for (Object primitiveToZoom : testError.getHighlighted()) { + primitivesToZoom.add((OsmPrimitive) primitiveToZoom); + } + + SelectCommand command = new SelectCommand(primitivesToZoom); + + List listOfLayers = Main.getLayerManager().getLayersOfType(OsmDataLayer.class); + for (OsmDataLayer osmDataLayer : listOfLayers) { + if (osmDataLayer.data == originalRelation.getDataSet()) { + + final OsmDataLayer layerParameter = osmDataLayer; + final Relation relationParameter = originalRelation; + final Collection zoomParameter = primitivesToZoom; + + if (SwingUtilities.isEventDispatchThread()) { + + showRelationEditorAndZoom(layerParameter, relationParameter, zoomParameter); + + } else { + + SwingUtilities.invokeLater(new Runnable() { + @Override + public void run() { + + showRelationEditorAndZoom(layerParameter, relationParameter, zoomParameter); + + } + }); + + } + + return command; + } + } + return null; + + } + + private static void showRelationEditorAndZoom(OsmDataLayer layer, Relation r, Collection primitives) { + + // zoom to problem: + AutoScaleAction.zoomTo(primitives); + + // put stop-related members to the front and edit roles if necessary: + List sortedRelationMembers = listStopMembers(r); + sortedRelationMembers.addAll(listNotStopMembers(r)); + r.setMembers(sortedRelationMembers); + + // create editor: + GenericRelationEditor editor = (GenericRelationEditor) RelationEditor.getEditor(layer, r, + r.getMembersFor(primitives)); + + // open editor: + editor.setVisible(true); + + // make the current relation purple in the pt_assistant layer: + PTAssistantLayer.getLayer().repaint(r); + }