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 32496) +++ /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/gui/PTAssistantLayer.java (revision 32497) @@ -1,5 +1,4 @@ package org.openstreetmap.josm.plugins.pt_assistant.gui; -import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.KeyboardFocusManager; @@ -164,10 +163,9 @@ Main.getLayerManager().addLayer(this); } - Graphics g = paintVisitor.getGraphics(); - paintVisitor = new PTAssistantPaintVisitor(g, Main.map.mapView); + for (OsmPrimitive primitive : primitives) { paintVisitor.visit(primitive); - } + Main.map.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 32496) +++ /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/gui/PTAssistantPaintVisitor.java (revision 32497) @@ -5,4 +5,5 @@ import java.awt.Graphics; import java.awt.Point; +import java.util.ArrayList; import java.util.HashMap; import java.util.List; @@ -18,4 +19,6 @@ import org.openstreetmap.josm.plugins.pt_assistant.utils.RouteUtils; +import com.sun.org.apache.regexp.internal.recompile; + public class PTAssistantPaintVisitor extends PaintVisitor { @@ -34,28 +37,36 @@ public void visit(Relation r) { + // first, draw primitives: + for (RelationMember rm : r.getMembers()) { + + if (RouteUtils.isPTStop(rm)) { + + drawStop(rm.getMember()); + + + } else if (RouteUtils.isPTWay(rm)) { + if (rm.isWay()) { + visit(rm.getWay()); + } else if (rm.isRelation()) { + visit(rm.getRelation()); + } else { + // if the relation has members that do not fit with the + // PT_Assistant data model, do nothing + } + } else { + // if the relation has members that do not fit with the + // PT_Assistant data model, do nothing + } + } + + // in the end, draw labels: HashMap stopOrderMap = new HashMap<>(); - int stopCount = 1; - + for (RelationMember rm : r.getMembers()) { - - // if (rm.getMember().isIncomplete() && (rm.isNode() || - // rm.hasRole("stop") || rm.hasRole("stop_entry_only") - // || rm.hasRole("stop_exit_only") || rm.hasRole("platform") || - // rm.hasRole("platform_entry_only") - // || rm.hasRole("platform_exit_only"))) { - // - // if (stopOrderMap.containsKey(rm.getUniqueId())) { - // label = stopOrderMap.get(rm.getUniqueId()); - // label = label + ";" + stopCount; - // } else { - // - // } - // } - if (RouteUtils.isPTStop(rm) || (rm.getMember().isIncomplete() && (rm.isNode() || rm.hasRole("stop") || rm.hasRole("stop_entry_only") || rm.hasRole("stop_exit_only") || rm.hasRole("platform") || rm.hasRole("platform_entry_only") || rm.hasRole("platform_exit_only")))) { - + String label = ""; @@ -76,22 +87,5 @@ stopOrderMap.put(rm.getUniqueId(), label); drawStopLabel(rm.getMember(), label); - if (!rm.getMember().isIncomplete()) { - drawStop(rm.getMember(), label); - } - stopCount++; - - } else if (RouteUtils.isPTWay(rm)) { - if (rm.isWay()) { - visit(rm.getWay()); - } else if (rm.isRelation()) { - visit(rm.getRelation()); - } else { - // if the relation has members that do not fit with the - // PT_Assistant data model, do nothing - } - } else { - // if the relation has members that do not fit with the - // PT_Assistant data model, do nothing } } @@ -245,9 +239,4 @@ } - // g.drawLine((int) (p1.x - cosT), (int) (p1.y - sinT), (int) (p2.x + - // cosT), (int) (p2.y - sinT)); - // g.drawLine((int) (p1.x - cosT), (int) (p1.y + sinT), (int) (p2.x - - // cosT), (int) (p2.y + sinT)); - } @@ -269,5 +258,5 @@ } - protected void drawStop(OsmPrimitive primitive, String label) { + protected void drawStop(OsmPrimitive primitive) { // find the point to which the stop visualization will be linked: @@ -304,40 +293,37 @@ g.setFont(stringFont); g.drawString(label, p.x + 20, p.y - 20); - - // get the parents of the primitive that are routes: + + // draw the ref values of all parent routes: + List parentsLabelList = new ArrayList<>(); String parentsLabel = ""; - for (OsmPrimitive parent: primitive.getReferrers()) { + for (OsmPrimitive parent : primitive.getReferrers()) { if (parent.getType().equals(OsmPrimitiveType.RELATION)) { Relation relation = (Relation) parent; if (RouteUtils.isTwoDirectionRoute(relation)) { - parentsLabel = parentsLabel + relation.get("ref") + ";"; - } - } - } + + boolean stringFound = false; + for (String s : parentsLabelList) { + if (s.equals(relation.get("ref"))) { + stringFound = true; + } + } + if (!stringFound) { + parentsLabel = parentsLabel + relation.get("ref") + ";"; + parentsLabelList.add(relation.get("ref")); + } + + } + } + } + if (!parentsLabel.equals("")) { // remove the last semicolon: - parentsLabel = parentsLabel.substring(0, parentsLabel.length()-1); - g.setColor(new Color(200, 200, 200)); + parentsLabel = parentsLabel.substring(0, parentsLabel.length() - 1); + g.setColor(new Color(150, 150, 150)); Font parentLabelFont = new Font("SansSerif", Font.ITALIC, 20); g.setFont(parentLabelFont); g.drawString(parentsLabel, p.x + 20, p.y); } - - } - -// protected void drawStopParentLabel(OsmPrimitive primitive, String label) { -// // find the point to which the stop visualization will be linked: -// Node n = new Node(primitive.getBBox().getCenter()); -// -// 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); -// } - - protected Graphics getGraphics() { - return this.g; + } Index: /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/DirectionTest.java =================================================================== --- /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/DirectionTest.java (revision 32496) +++ /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/DirectionTest.java (revision 32497) @@ -88,5 +88,5 @@ highlighted.add(waysToCheck.get(i).getWay()); errors.add(new TestError(this, Severity.WARNING, - tr("PT: Route passes a oneway road in wrong direction"), ERROR_CODE_DIRECTION, primitives, + tr("PT: Route passes a oneway road in the wrong direction"), ERROR_CODE_DIRECTION, primitives, highlighted)); return; Index: /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/PTAssitantValidatorTest.java =================================================================== --- /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/PTAssitantValidatorTest.java (revision 32496) +++ /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/PTAssitantValidatorTest.java (revision 32497) @@ -69,13 +69,12 @@ } -// if (!Main.getLayerManager().containsLayer(layer)) { -// Main.getLayerManager().addLayer(layer); -// } -// layer.clear(); -// layer.addPrimitive(r); // Check individual ways using the oneway direction test and the road // type test: WayChecker wayChecker = new WayChecker(r, this); + if (!r.hasIncompleteMembers()) { + wayChecker.performDirectionTest(); + wayChecker.performRoadTypeTest(); + } this.errors.addAll(wayChecker.getErrors()); @@ -170,4 +169,5 @@ // Check if the relation is correct, or only has a wrong sorting order: RouteChecker routeChecker = new RouteChecker(r, this); + routeChecker.performSortingTest(); List routeCheckerErrors = routeChecker.getErrors(); @@ -236,11 +236,15 @@ List commands = new ArrayList<>(); - if (testError.getCode() == ERROR_CODE_DIRECTION || testError.getCode() == ERROR_CODE_ROAD_TYPE + if (testError.getCode() == ERROR_CODE_ROAD_TYPE || testError.getCode() == ERROR_CODE_CONSTRUCTION) { - commands.add(fixErrorByRemovingWay(testError)); + commands.add(WayChecker.fixErrorByRemovingWay(testError)); + } + + if (testError.getCode() == ERROR_CODE_DIRECTION) { + commands.add(WayChecker.fixErrorByZooming(testError)); } if (testError.getCode() == ERROR_CODE_SORTING) { - commands.add(fixSortingError(testError)); + commands.add(RouteChecker.fixSortingError(testError)); } @@ -282,121 +286,121 @@ } - private Command fixErrorByRemovingWay(TestError testError) { - - if (testError.getCode() != ERROR_CODE_ROAD_TYPE && testError.getCode() != ERROR_CODE_DIRECTION) { - return null; - } - - Collection primitives = testError.getPrimitives(); - Relation originalRelation = (Relation) primitives.iterator().next(); - Collection highlighted = testError.getHighlighted(); - Way wayToRemove = (Way) highlighted.iterator().next(); - - Relation modifiedRelation = new Relation(originalRelation); - List modifiedRelationMembers = new ArrayList<>(originalRelation.getMembersCount() - 1); - - // copy PT stops first, PT ways last: - for (RelationMember rm : originalRelation.getMembers()) { - 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); - } - - } - } - - // now copy PT ways: - for (RelationMember rm : originalRelation.getMembers()) { - if (RouteUtils.isPTWay(rm)) { - Way wayToCheck = rm.getWay(); - if (wayToCheck != wayToRemove) { - if (rm.getRole().equals("forward") || rm.getRole().equals("backward")) { - RelationMember modifiedMember = new RelationMember("", wayToCheck); - modifiedRelationMembers.add(modifiedMember); - } else { - modifiedRelationMembers.add(rm); - } - } - } - } - - modifiedRelation.setMembers(modifiedRelationMembers); - - ChangeCommand changeCommand = new ChangeCommand(originalRelation, modifiedRelation); - - return changeCommand; - } - - private Command fixSortingError(TestError testError) { - if (testError.getCode() != ERROR_CODE_SORTING) { - return null; - } - - Collection primitives = testError.getPrimitives(); - Relation originalRelation = (Relation) primitives.iterator().next(); - - // separate ways from stops (because otherwise the order of - // stops/platforms can be messed up by the sorter: - List members = originalRelation.getMembers(); - final List stops = new ArrayList<>(); - final List ways = new ArrayList<>(); - for (RelationMember member : members) { - if (RouteUtils.isPTWay(member)) { - if (member.getRole().equals("")) { - ways.add(member); - } else { - RelationMember modifiedMember = new RelationMember("", member.getWay()); - ways.add(modifiedMember); - } - - } else { // stops: - if (member.getRole().equals("stop_positon")) { - // it is not expected that stop_positions could - // be relations - if (member.getType().equals(OsmPrimitiveType.NODE)) { - RelationMember modifiedMember = new RelationMember("stop", member.getNode()); - stops.add(modifiedMember); - } else { // if it is a primitive of type way: - RelationMember modifiedMember = new RelationMember("stop", member.getWay()); - stops.add(modifiedMember); - } - } else { // if it is not a stop_position: - stops.add(member); - } - - } - } - - // sort the ways: - RelationSorter sorter = new RelationSorter(); - List sortedWays = sorter.sortMembers(ways); - - // create a new relation to pass to the command: - Relation sortedRelation = new Relation(originalRelation); - List sortedRelationMembers = new ArrayList<>(members.size()); - for (RelationMember rm : stops) { - sortedRelationMembers.add(rm); - } - for (RelationMember rm : sortedWays) { - sortedRelationMembers.add(rm); - } - sortedRelation.setMembers(sortedRelationMembers); - - ChangeCommand changeCommand = new ChangeCommand(originalRelation, sortedRelation); - - return changeCommand; - - } +// private Command fixErrorByRemovingWay(TestError testError) { +// +// if (testError.getCode() != ERROR_CODE_ROAD_TYPE && testError.getCode() != ERROR_CODE_DIRECTION) { +// return null; +// } +// +// Collection primitives = testError.getPrimitives(); +// Relation originalRelation = (Relation) primitives.iterator().next(); +// Collection highlighted = testError.getHighlighted(); +// Way wayToRemove = (Way) highlighted.iterator().next(); +// +// Relation modifiedRelation = new Relation(originalRelation); +// List modifiedRelationMembers = new ArrayList<>(originalRelation.getMembersCount() - 1); +// +// // copy PT stops first, PT ways last: +// for (RelationMember rm : originalRelation.getMembers()) { +// 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); +// } +// +// } +// } +// +// // now copy PT ways: +// for (RelationMember rm : originalRelation.getMembers()) { +// if (RouteUtils.isPTWay(rm)) { +// Way wayToCheck = rm.getWay(); +// if (wayToCheck != wayToRemove) { +// if (rm.getRole().equals("forward") || rm.getRole().equals("backward")) { +// RelationMember modifiedMember = new RelationMember("", wayToCheck); +// modifiedRelationMembers.add(modifiedMember); +// } else { +// modifiedRelationMembers.add(rm); +// } +// } +// } +// } +// +// modifiedRelation.setMembers(modifiedRelationMembers); +// +// ChangeCommand changeCommand = new ChangeCommand(originalRelation, modifiedRelation); +// +// return changeCommand; +// } +// +// private Command fixSortingError(TestError testError) { +// if (testError.getCode() != ERROR_CODE_SORTING) { +// return null; +// } +// +// Collection primitives = testError.getPrimitives(); +// Relation originalRelation = (Relation) primitives.iterator().next(); +// +// // separate ways from stops (because otherwise the order of +// // stops/platforms can be messed up by the sorter: +// List members = originalRelation.getMembers(); +// final List stops = new ArrayList<>(); +// final List ways = new ArrayList<>(); +// for (RelationMember member : members) { +// if (RouteUtils.isPTWay(member)) { +// if (member.getRole().equals("")) { +// ways.add(member); +// } else { +// RelationMember modifiedMember = new RelationMember("", member.getWay()); +// ways.add(modifiedMember); +// } +// +// } else { // stops: +// if (member.getRole().equals("stop_positon")) { +// // it is not expected that stop_positions could +// // be relations +// if (member.getType().equals(OsmPrimitiveType.NODE)) { +// RelationMember modifiedMember = new RelationMember("stop", member.getNode()); +// stops.add(modifiedMember); +// } else { // if it is a primitive of type way: +// RelationMember modifiedMember = new RelationMember("stop", member.getWay()); +// stops.add(modifiedMember); +// } +// } else { // if it is not a stop_position: +// stops.add(member); +// } +// +// } +// } +// +// // sort the ways: +// RelationSorter sorter = new RelationSorter(); +// List sortedWays = sorter.sortMembers(ways); +// +// // create a new relation to pass to the command: +// Relation sortedRelation = new Relation(originalRelation); +// List sortedRelationMembers = new ArrayList<>(members.size()); +// for (RelationMember rm : stops) { +// sortedRelationMembers.add(rm); +// } +// for (RelationMember rm : sortedWays) { +// sortedRelationMembers.add(rm); +// } +// sortedRelation.setMembers(sortedRelationMembers); +// +// ChangeCommand changeCommand = new ChangeCommand(originalRelation, sortedRelation); +// +// return changeCommand; +// +// } private void performDummyTest(Relation r) { Index: /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/RouteChecker.java =================================================================== --- /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/RouteChecker.java (revision 32496) +++ /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/RouteChecker.java (revision 32497) @@ -4,6 +4,10 @@ import java.util.ArrayList; +import java.util.Collection; import java.util.List; +import org.openstreetmap.josm.command.ChangeCommand; +import org.openstreetmap.josm.command.Command; +import org.openstreetmap.josm.data.osm.OsmPrimitive; import org.openstreetmap.josm.data.osm.OsmPrimitiveType; import org.openstreetmap.josm.data.osm.Relation; @@ -35,9 +39,7 @@ this.hasGap = false; - performSortingTest(); - } - private void performSortingTest() { + protected void performSortingTest() { final List waysToCheck = new ArrayList<>(); @@ -108,4 +110,65 @@ } + + protected static Command fixSortingError(TestError testError) { + if (testError.getCode() != PTAssitantValidatorTest.ERROR_CODE_SORTING) { + return null; + } + + Collection primitives = testError.getPrimitives(); + Relation originalRelation = (Relation) primitives.iterator().next(); + + // separate ways from stops (because otherwise the order of + // stops/platforms can be messed up by the sorter: + List members = originalRelation.getMembers(); + final List stops = new ArrayList<>(); + final List ways = new ArrayList<>(); + for (RelationMember member : members) { + if (RouteUtils.isPTWay(member)) { + if (member.getRole().equals("")) { + ways.add(member); + } else { + RelationMember modifiedMember = new RelationMember("", member.getWay()); + ways.add(modifiedMember); + } + + } else { // stops: + if (member.getRole().equals("stop_positon")) { + // it is not expected that stop_positions could + // be relations + if (member.getType().equals(OsmPrimitiveType.NODE)) { + RelationMember modifiedMember = new RelationMember("stop", member.getNode()); + stops.add(modifiedMember); + } else { // if it is a primitive of type way: + RelationMember modifiedMember = new RelationMember("stop", member.getWay()); + stops.add(modifiedMember); + } + } else { // if it is not a stop_position: + stops.add(member); + } + + } + } + + // sort the ways: + RelationSorter sorter = new RelationSorter(); + List sortedWays = sorter.sortMembers(ways); + + // create a new relation to pass to the command: + Relation sortedRelation = new Relation(originalRelation); + List sortedRelationMembers = new ArrayList<>(members.size()); + for (RelationMember rm : stops) { + sortedRelationMembers.add(rm); + } + for (RelationMember rm : sortedWays) { + sortedRelationMembers.add(rm); + } + sortedRelation.setMembers(sortedRelationMembers); + + ChangeCommand changeCommand = new ChangeCommand(originalRelation, sortedRelation); + + return changeCommand; + + } } Index: /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/WayChecker.java =================================================================== --- /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/WayChecker.java (revision 32496) +++ /applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/WayChecker.java (revision 32497) @@ -4,6 +4,11 @@ import java.util.ArrayList; +import java.util.Collection; import java.util.List; +import org.openstreetmap.josm.command.ChangeCommand; +import org.openstreetmap.josm.command.Command; +import org.openstreetmap.josm.command.SelectCommand; +import org.openstreetmap.josm.data.osm.OsmPrimitive; import org.openstreetmap.josm.data.osm.OsmPrimitiveType; import org.openstreetmap.josm.data.osm.OsmUtils; @@ -30,13 +35,7 @@ super(relation, test); - if (!relation.hasIncompleteMembers()) { - this.performDirectionTest(); - this.performRoadTypeTest(); - } - - - } - - private void performRoadTypeTest() { + } + + protected void performRoadTypeTest() { if (!relation.hasTag("route", "bus") && !relation.hasTag("route", "trolleybus") @@ -133,5 +132,5 @@ } - private void performDirectionTest() { + protected void performDirectionTest() { List waysToCheck = new ArrayList<>(); @@ -172,5 +171,5 @@ highlighted.add(waysToCheck.get(i).getWay()); TestError e = new TestError(this.test, Severity.WARNING, - tr("PT: Route passes a oneway road in wrong direction"), + tr("PT: Route passes a oneway road in the wrong direction"), PTAssitantValidatorTest.ERROR_CODE_DIRECTION, primitives, highlighted); this.errors.add(e); @@ -191,5 +190,5 @@ * @return true if the way is suitable for buses, false otherwise. */ - public boolean isWaySuitableForBuses(Way way) { + private boolean isWaySuitableForBuses(Way way) { if (way.hasTag("highway", "motorway") || way.hasTag("highway", "trunk") || way.hasTag("highway", "primary") || way.hasTag("highway", "secondary") || way.hasTag("highway", "tertiary") @@ -211,4 +210,81 @@ return false; } - + + protected static Command fixErrorByRemovingWay(TestError testError) { + + if (testError.getCode() != PTAssitantValidatorTest.ERROR_CODE_ROAD_TYPE && testError.getCode() != PTAssitantValidatorTest.ERROR_CODE_DIRECTION) { + return null; + } + + Collection primitives = testError.getPrimitives(); + Relation originalRelation = (Relation) primitives.iterator().next(); + Collection highlighted = testError.getHighlighted(); + Way wayToRemove = (Way) highlighted.iterator().next(); + + Relation modifiedRelation = new Relation(originalRelation); + List modifiedRelationMembers = new ArrayList<>(originalRelation.getMembersCount() - 1); + + // copy PT stops first, PT ways last: + for (RelationMember rm : originalRelation.getMembers()) { + 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); + } + + } + } + + // now copy PT ways: + for (RelationMember rm : originalRelation.getMembers()) { + if (RouteUtils.isPTWay(rm)) { + Way wayToCheck = rm.getWay(); + if (wayToCheck != wayToRemove) { + if (rm.getRole().equals("forward") || rm.getRole().equals("backward")) { + RelationMember modifiedMember = new RelationMember("", wayToCheck); + modifiedRelationMembers.add(modifiedMember); + } else { + modifiedRelationMembers.add(rm); + } + } + } + } + + modifiedRelation.setMembers(modifiedRelationMembers); + + ChangeCommand changeCommand = new ChangeCommand(originalRelation, modifiedRelation); + + return changeCommand; + } + + + protected static Command fixErrorByZooming(TestError testError) { + + if (testError.getCode() != PTAssitantValidatorTest.ERROR_CODE_DIRECTION) { + return null; + } + +// Collection primitives = testError.getPrimitives(); +// Relation originalRelation = (Relation) primitives.iterator().next(); + Collection highlighted = testError.getHighlighted(); + Way wayToHighlight = (Way) highlighted.iterator().next(); + ArrayList primitivesToHighlight = new ArrayList<>(1); + primitivesToHighlight.add(wayToHighlight); + + SelectCommand command = new SelectCommand(primitivesToHighlight); + + return command; + + } + }