Changeset 32230 in osm


Ignore:
Timestamp:
2016-06-10T20:31:05+02:00 (9 years ago)
Author:
darya
Message:

Routes with incomplete members excluded, tests for roundaboouts and overshoots disabled

Location:
applications/editors/josm
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/PTAssistantPlugin.java

    r32226 r32230  
    22package org.openstreetmap.josm.plugins.pt_assistant;
    33
     4import static org.openstreetmap.josm.tools.I18n.tr;
     5
     6import javax.swing.JOptionPane;
     7
     8import org.openstreetmap.josm.data.osm.Relation;
     9import org.openstreetmap.josm.data.osm.RelationMember;
    410import org.openstreetmap.josm.data.validation.OsmValidator;
    511import org.openstreetmap.josm.plugins.Plugin;
    … …  
    1723 */
    1824public class PTAssistantPlugin extends Plugin {
    19 
     25       
    2026        /**
    2127         * Main constructor.
    … …  
    3440
    3541        }
     42       
     43
    3644
    3745

  • applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/utils/RouteUtils.java

    r32222 r32230  
    11package org.openstreetmap.josm.plugins.pt_assistant.utils;
    22
     3import static org.openstreetmap.josm.tools.I18n.tr;
     4
     5import java.util.ArrayList;
     6import java.util.List;
     7
     8import javax.swing.JCheckBox;
     9import javax.swing.JOptionPane;
     10
     11import org.openstreetmap.josm.actions.DownloadPrimitiveAction;
    312import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
     13import org.openstreetmap.josm.data.osm.PrimitiveId;
    414import org.openstreetmap.josm.data.osm.Relation;
    515import org.openstreetmap.josm.data.osm.RelationMember;
    … …  
    1424public class RouteUtils {
    1525
     26        // indicates if the user needs to be asked before fetching incomplete
     27        // members of a relation.
     28
     29        private enum ASK_TO_FETCH {
     30                DO_ASK, DONT_ASK_AND_FETCH, DONT_ASK_AND_DONT_FETCH
     31        };
     32
     33        private static ASK_TO_FETCH askToFetch = ASK_TO_FETCH.DO_ASK;
     34       
     35        // checks that the same relation is only fetched once
     36        private static Relation lastRelationToFetch = null;
     37
    1638        private RouteUtils() {
    1739                // private constructor for util classes
    … …  
    6688                                || w.hasTag("railway", "platform") || w.hasTag("public_transport", "platform_entry_only")
    6789                                || w.hasTag("highway", "platform_entry_only") || w.hasTag("railway", "platform_entry_only")
    68                                 || w.hasTag("public_transport", "platform_exit_only") || w.hasTag("highway", "platform_exit_only") || w.hasTag("railway", "platform_exit_only")) {
     90                                || w.hasTag("public_transport", "platform_exit_only") || w.hasTag("highway", "platform_exit_only")
     91                                || w.hasTag("railway", "platform_exit_only")) {
    6992                        return true;
    7093                }
    … …  
    113136        }
    114137
     138        /**
     139         * Checks if all members of a relation are complete. If not, the user is
     140         * asked to confirm the permission to fetch them, and they are fetched. The
     141         * completeness of the relation itself is not checked.
     142         *
     143         * @param r
     144         *            relation
     145         * @return true if all relation members are complete (or fetched), false
     146         *         otherwise (including if the user denies permission to download
     147         *         data)
     148         * TODO: what should be done in case the connection to the server is broken
     149         */
     150        public static boolean ensureMemberCompleteness(Relation r) {
     151               
     152                if (r == null) {
     153                        return false;
     154                }
     155
     156                boolean isComplete = true;
     157
     158                // check if there is at least one incomplete relation member:
     159                for (RelationMember rm : r.getMembers()) {
     160                        if ((rm.isNode() && rm.getNode().isIncomplete()) || (rm.isWay() && rm.getWay().isIncomplete())
     161                                        || (rm.isRelation() && rm.getRelation().isIncomplete())) {
     162                                isComplete = false;
     163                                break;
     164                        }
     165                }
     166
     167                if (!isComplete && !r.equals(lastRelationToFetch)) {
     168
     169                        int userInput = Integer.MIN_VALUE;
     170                       
     171
     172                        if (askToFetch == ASK_TO_FETCH.DO_ASK) {
     173                                String message = tr("The relation (id=" + r.getId()
     174                                                + ") has incomplete members.\nThey need to be downloaded to proceed with validation of this relation.\nDo you want to download incomplete members?");
     175                                JCheckBox checkbox = new JCheckBox(tr("Remember my choice and don't ask me again in this session"));
     176                                Object[] params = { message, checkbox };
     177                                String[] options = { tr("Yes"), tr("No") };
     178                                // ask the user:
     179                                userInput = JOptionPane.showOptionDialog(null, params, tr("Fetch Request"), JOptionPane.YES_NO_OPTION,
     180                                                JOptionPane.QUESTION_MESSAGE, null, options, 0);
     181                               
     182
     183                                // if the user does not want to be asked:
     184                                if (checkbox.isSelected()) {
     185                                        if (userInput == 0) {
     186                                                askToFetch = ASK_TO_FETCH.DONT_ASK_AND_FETCH;
     187                                        } else {
     188                                                askToFetch = ASK_TO_FETCH.DONT_ASK_AND_DONT_FETCH;
     189                                        }
     190                                }
     191                        }
     192
     193                        // if the user does want to fetch:
     194                        if (userInput == 0 || askToFetch == ASK_TO_FETCH.DONT_ASK_AND_FETCH) {
     195                                List<PrimitiveId> list = new ArrayList<>(1);
     196                                list.add(r);
     197                                DownloadPrimitiveAction.processItems(false, list, false, true);
     198                                isComplete = true;
     199                                lastRelationToFetch = r;
     200
     201                        }
     202
     203                }
     204
     205                return isComplete;
     206        }
     207       
     208       
     209        public static boolean hasIncompleteMembers(Relation r) {
     210                if (r == null) {
     211                        return true;
     212                }
     213                for (RelationMember rm: r.getMembers()) {
     214                        if ((rm.isNode() && rm.getNode().isIncomplete()) || (rm.isWay() && rm.getWay().isIncomplete())
     215                                        || (rm.isRelation() && rm.getRelation().isIncomplete())) {
     216                                return true;
     217                        }
     218                }
     219               
     220                return false;
     221        }
     222       
     223//      /**
     224//       * TODO: this is temporal
     225//       */
     226//      public static String getFetch() {
     227//              if (askToFetch == ASK_TO_FETCH.DO_ASK) {
     228//                      return "do ask";
     229//              }
     230//              if (askToFetch == ASK_TO_FETCH.DONT_ASK_AND_FETCH) {
     231//                      return "don;t ask and fetch";
     232//              }
     233//              return "don't ask and don't fetch";
     234//      }
     235
    115236}

  • applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/utils/StopToWayAssigner.java

    r32216 r32230  
    11package org.openstreetmap.josm.plugins.pt_assistant.utils;
    22
    3 import java.util.LinkedList;
     3import java.util.ArrayList;
     4import java.util.HashMap;
    45import java.util.List;
    56
    67import org.openstreetmap.josm.data.osm.Node;
     8import org.openstreetmap.josm.data.osm.OsmPrimitive;
    79import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
    810import org.openstreetmap.josm.data.osm.Relation;
    9 import org.openstreetmap.josm.data.osm.RelationMember;
    1011import org.openstreetmap.josm.data.osm.Way;
    1112
    1213public final class StopToWayAssigner {
    13        
    14         private StopToWayAssigner() {
    15                 // Hide default constructor for utils classes           
     14
     15        private static HashMap<Long, Way> stopToWay = new HashMap<>();
     16
     17        private StopToWayAssigner(Relation r) {
     18                // Hide default constructor for utils classes
     19        }
     20
     21        public static Way getWay(OsmPrimitive stop, Relation route) {
     22                if (stopToWay.containsKey(stop.getId())) {
     23                        return stopToWay.get(stop.getId());
     24                }
     25               
     26
     27               
     28               
     29                if (stop.getType().equals(OsmPrimitiveType.NODE)) {
     30                        List<OsmPrimitive> referrers = stop.getReferrers();
     31                        List<Way> referredWays = new ArrayList<>();
     32                        for (OsmPrimitive referrer: referrers) {
     33                                if (referrer.getType().equals(OsmPrimitiveType.WAY)) {
     34                                        referredWays.add((Way)referrer);
     35                                }
     36                        }
     37                        if (stop.hasTag("public_transport", "stop_position")) {
     38                                // TODO
     39                                Node n = (Node) stop;
     40                        }
     41                }
     42
     43                // TODO: algorithm with growing bounding boxes
     44                // TODO: if found, add to
     45                return null;
    1646        }
    1747       
    18         public static Way getWay(Node stop, Relation route) {
    19                 List<Way> ways = new LinkedList<>();
    20                 List<RelationMember> members = route.getMembers();
    21                 for (RelationMember member: members) {
    22                         if (member.getType().equals(OsmPrimitiveType.WAY)) {
    23                                 ways.add(member.getWay());
    24                         }
     48        /**
     49         * Remove a map entry
     50         * @param stopId
     51         */
     52        public static void removeStopKey(long stopId) {
     53                Long id = new Long(stopId);
     54                if (stopToWay.containsKey(id)) {
     55                        stopToWay.remove(id);
    2556                }
    26                 // TODO: algorithm with growing bounding boxes
    27                 return null;
     57        }
     58
     59        /**
     60         * May be needed if the correspondence between stops and ways has changed
     61         * significantly
     62         */
     63        public static void reinitiate() {
     64                stopToWay = new HashMap<>();
    2865        }
    2966

  • applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/DirectionTest.java

    r32228 r32230  
    66import java.util.List;
    77
     8import javax.swing.JOptionPane;
     9
    810import org.openstreetmap.josm.command.ChangeCommand;
    911import org.openstreetmap.josm.command.Command;
    1012import org.openstreetmap.josm.command.SequenceCommand;
     13import org.openstreetmap.josm.data.osm.Node;
    1114import org.openstreetmap.josm.data.osm.OsmPrimitive;
    1215import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
    … …  
    2528
    2629        public static final int ERROR_CODE_DIRECTION = 3731;
    27         public static final int ERROR_CODE_ROUNDABOUT = 3732;
     30        public static final int ERROR_CODE_UNSPLIT_ROUNDABOUT = 3732;
     31        public static final int ERROR_CODE_SPLIT_ROUNDABOUT = 3733;
    2832
    2933        public DirectionTest() {
    3034                super(tr("Direction Test"), tr("Checks if the route runs against the direction of underlying one-way roads"));
     35
    3136        }
    3237
    … …  
    3439        public void visit(Relation r) {
    3540
    36                 if (RouteUtils.isTwoDirectionRoute(r)) {
     41                if (!RouteUtils.isTwoDirectionRoute(r)) {
     42                        return;
     43                }
    3744
    38                         List<RelationMember> waysToCheck = new ArrayList<>();
     45//              boolean isComplete = RouteUtils.ensureMemberCompleteness(r);
     46//              if (!isComplete) {
     47//                      return;
     48//              }
     49               
     50                if (RouteUtils.hasIncompleteMembers(r)) {
     51                        return;
     52                }
    3953
    40                         for (RelationMember rm : r.getMembers()) {
    41                                 if (RouteUtils.isPTWay(rm) && rm.getType().equals(OsmPrimitiveType.WAY)) {
    42                                         waysToCheck.add(rm);
     54                List<RelationMember> waysToCheck = new ArrayList<>();
     55
     56                for (RelationMember rm : r.getMembers()) {
     57                        if (RouteUtils.isPTWay(rm) && rm.getType().equals(OsmPrimitiveType.WAY)) {
     58                                waysToCheck.add(rm);
     59                        }
     60                }
     61
     62                if (waysToCheck.isEmpty()) {
     63                        return;
     64                }
     65
     66                WayConnectionTypeCalculator connectionTypeCalculator = new WayConnectionTypeCalculator();
     67                final List<WayConnectionType> links = connectionTypeCalculator.updateLinks(waysToCheck);
     68
     69                for (int i = 0; i < links.size(); i++) {
     70                        if ((OsmUtils.isTrue(waysToCheck.get(i).getWay().get("oneway"))
     71                                        && links.get(i).direction.equals(WayConnectionType.Direction.BACKWARD))
     72                                        || (OsmUtils.isReversed(waysToCheck.get(i).getWay().get("oneway"))
     73                                                        && links.get(i).direction.equals(WayConnectionType.Direction.FORWARD))) {
     74
     75                                // At this point, the PTWay is going against the oneway
     76                                // direction. Check if this road allows buses to disregard
     77                                // the oneway restriction:
     78
     79                                if (!waysToCheck.get(i).getWay().hasTag("busway", "lane")
     80                                                && !waysToCheck.get(i).getWay().hasTag("oneway:bus", "no")
     81                                                && !waysToCheck.get(i).getWay().hasTag("busway", "opposite_lane")
     82                                                && !waysToCheck.get(i).getWay().hasTag("oneway:psv", "no")
     83                                                && !waysToCheck.get(i).getWay().hasTag("trolley_wire", "backward")) {
     84                                        List<Relation> primitives = new ArrayList<>(1);
     85                                        primitives.add(r);
     86                                        List<Way> highlighted = new ArrayList<>(1);
     87                                        highlighted.add(waysToCheck.get(i).getWay());
     88                                        errors.add(new TestError(this, Severity.WARNING,
     89                                                        tr("PT: Route passes a oneway road in wrong direction"), ERROR_CODE_DIRECTION, primitives,
     90                                                        highlighted));
     91                                        return;
    4392                                }
     93
    4494                        }
    4595
    46                         if (waysToCheck.isEmpty()) {
    47                                 return;
    48                         }
    49 
    50                         WayConnectionTypeCalculator connectionTypeCalculator = new WayConnectionTypeCalculator();
    51                         final List<WayConnectionType> links = connectionTypeCalculator.updateLinks(waysToCheck);
    52 
    53                         for (int i = 0; i < links.size(); i++) {
    54                                 if ((OsmUtils.isTrue(waysToCheck.get(i).getWay().get("oneway"))
    55                                                 && links.get(i).direction.equals(WayConnectionType.Direction.BACKWARD))
    56                                                 || (OsmUtils.isReversed(waysToCheck.get(i).getWay().get("oneway"))
    57                                                                 && links.get(i).direction.equals(WayConnectionType.Direction.FORWARD))) {
    58 
    59                                         // At this point, the PTWay is going against the oneway
    60                                         // direction. Check if this road allows buses to disregard
    61                                         // the oneway restriction:
    62 
    63                                         if (!waysToCheck.get(i).getWay().hasTag("busway", "lane")
    64                                                         && !waysToCheck.get(i).getWay().hasTag("oneway:bus", "no")
    65                                                         && !waysToCheck.get(i).getWay().hasTag("busway", "opposite_lane")
    66                                                         && !waysToCheck.get(i).getWay().hasTag("oneway:psv", "no")
    67                                                         && !waysToCheck.get(i).getWay().hasTag("trolley_wire", "backward")) {
    68                                                 List<Relation> primitives = new ArrayList<>(1);
    69                                                 primitives.add(r);
    70                                                 List<Way> highlighted = new ArrayList<>(1);
    71                                                 highlighted.add(waysToCheck.get(i).getWay());
    72                                                 errors.add(new TestError(this, Severity.WARNING,
    73                                                                 tr("PT: Route passes a oneway road in wrong direction"), ERROR_CODE_DIRECTION,
    74                                                                 primitives, highlighted));
    75                                         }
    76 
    77                                 }
    78 
    79                                 if (links.get(i).direction.equals(WayConnectionType.Direction.ROUNDABOUT_LEFT)
    80                                                 || links.get(i).direction.equals(WayConnectionType.Direction.ROUNDABOUT_RIGHT)) {
    81                                         errors.add(new TestError(this, Severity.WARNING, tr("PT: Route passes on an unsplit roundabout"),
    82                                                         ERROR_CODE_ROUNDABOUT, waysToCheck.get(i).getWay()));
    83                                 }
    84                         }
     96//                      if (links.get(i).direction.equals(WayConnectionType.Direction.ROUNDABOUT_LEFT)
     97//                                      || links.get(i).direction.equals(WayConnectionType.Direction.ROUNDABOUT_RIGHT)) {
     98//                              errors.add(new TestError(this, Severity.WARNING, tr("PT: Route passes on an unsplit roundabout"),
     99//                                              ERROR_CODE_UNSPLIT_ROUNDABOUT, waysToCheck.get(i).getWay()));
     100//                              return;
     101//                      }
     102                       
     103//                      if (waysToCheck.get(i).getWay().hasTag("junction", "roundabout")) {
     104//                              JOptionPane.showMessageDialog(null, waysToCheck.get(i).getWay().getId() + " linkPrev: " + links.get(i).linkPrev + ", linkNext: " + links.get(i).linkNext);
     105////                            Node firstNode = waysToCheck.get(i).getWay().firstNode();
     106////                            Node lastNode = waysToCheck.get(index)
     107////                            if (i == 0 && waysToCheck.size() > 1) {
     108////                                    // if this is the very first way:
     109////                                   
     110////                            }
     111//                      }
     112                       
    85113
    86114                }
     115
    87116        }
    88117

  • applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/GapTest.java

    r32226 r32230  
    55import java.util.ArrayList;
    66import java.util.List;
     7
     8import javax.swing.JOptionPane;
    79
    810import org.openstreetmap.josm.command.ChangeCommand;
    … …  
    2628        public static final int ERROR_CODE_SORTING = 3711;
    2729        public static final int ERROR_CODE_OVERSHOOT = 3712;
     30        public static final int ERROR_CODE_SPLITTING = 3713;
    2831        public static final int ERROR_CODE_OTHER_GAP = 3719;
    2932
    … …  
    3639        @Override
    3740        public void visit(Relation r) {
    38 
    39                 if (RouteUtils.isTwoDirectionRoute(r)) {
    40                         List<RelationMember> members = r.getMembers();
    41                         final List<RelationMember> waysToCheck = new ArrayList<>();
    42                         for (RelationMember member : members) {
    43 
    44                                 if (RouteUtils.isPTWay(member)) {
    45                                         waysToCheck.add(member);
    46                                 }
    47                         }
    48 
    49                         if (waysToCheck.isEmpty()) {
    50                                 return;
    51                         }
    52 
    53                         if (hasGap(waysToCheck)) {
    54                                 RelationSorter sorter = new RelationSorter();
    55                                 List<RelationMember> correctedList = sorter.sortMembers(waysToCheck);
    56 
    57                                 if (!hasGap(correctedList)) {
     41               
     42                if (!RouteUtils.isTwoDirectionRoute(r)) {
     43                        return;
     44                }
     45
     46//              boolean isComplete = RouteUtils.ensureMemberCompleteness(r);
     47//              if (!isComplete) {
     48//                      return;
     49//              }
     50               
     51                if (RouteUtils.hasIncompleteMembers(r)) {
     52                        return;
     53                }
     54               
     55                List<RelationMember> members = r.getMembers();
     56                final List<RelationMember> waysToCheck = new ArrayList<>();
     57                for (RelationMember member : members) {
     58
     59                        if (RouteUtils.isPTWay(member)) {
     60                                waysToCheck.add(member);
     61                        }
     62                }
     63
     64                if (waysToCheck.isEmpty()) {
     65                        return;
     66                }
     67
     68                if (hasGap(waysToCheck)) {
     69                        RelationSorter sorter = new RelationSorter();
     70                        List<RelationMember> correctedList = sorter.sortMembers(waysToCheck);
     71
     72                        if (!hasGap(correctedList)) {
     73                                errors.add(new TestError(this, Severity.WARNING,
     74                                                tr("PT: Route contains a gap that can be fixed by sorting"), ERROR_CODE_SORTING, r));
     75                        } else {
     76                                // List<RelationMember> overshoots =
     77                                // this.getOvershoots(correctedList);
     78                                // if (!overshoots.isEmpty()) {
     79                                // // TODO: make sure that duplicates are removed first
     80                                // for (RelationMember overshoot : overshoots) {
     81                                // List<Relation> primitives = new ArrayList<>(1);
     82                                // primitives.add(r);
     83                                // List<Way> highlighted = new ArrayList<>(1);
     84                                // highlighted.add(overshoot.getWay());
     85                                // errors.add(new TestError(this, Severity.WARNING, tr("PT:
     86                                // Route contains an overshoot"),
     87                                // ERROR_CODE_OVERSHOOT, primitives, highlighted));
     88                                // }
     89                                //
     90                                // } else {
    5891                                        errors.add(new TestError(this, Severity.WARNING,
    59                                                         tr("PT: Route contains a gap that can be fixed by sorting"), ERROR_CODE_SORTING, r));
    60                                 } else {
    61                                         List<RelationMember> overshoots = this.getOvershoots(correctedList);
    62                                         if (!overshoots.isEmpty()) {
    63                                                 // TODO: make sure that duplicates are removed first
    64                                                 overshootList = overshoots;
    65                                                 errors.add(new TestError(this, Severity.WARNING, tr("PT: Route contains an overshoot"),
    66                                                                 ERROR_CODE_OVERSHOOT, r));
    67                                         } else {
    68                                                 errors.add(new TestError(this, Severity.WARNING,
    69                                                                 tr("PT: Route contains a gap that cannot be fixed by sorting the ways"),
    70                                                                 ERROR_CODE_OTHER_GAP, r));
    71                                         }
    72                                 }
    73 
     92                                                        tr("PT: Route contains a gap that cannot be fixed by sorting the ways"),
     93                                                        ERROR_CODE_OTHER_GAP, r));
     94//                              }
    7495                        }
    7596
    … …  
    98119                        }
    99120                }
    100                
    101                
    102121
    103122                return false;
    … …  
    191210                                                } else { // stops:
    192211                                                        if (member.getRole().equals("stop_positon")) {
    193                                                                 // it is not expected that stop_positions could be relations
     212                                                                // it is not expected that stop_positions could
     213                                                                // be relations
    194214                                                                if (member.getType().equals(OsmPrimitiveType.NODE)) {
    195215                                                                        RelationMember modifiedMember = new RelationMember("stop", member.getNode());
    … …  
    230250
    231251                        // if the error is a single overshoot:
    232                         if (testError.getCode() == ERROR_CODE_OVERSHOOT) {
    233 
    234                                 for (OsmPrimitive primitive : testError.getPrimitives()) {
    235                                         Relation originalRelation = (Relation) primitive;
    236                                         Relation modifiedRelation = new Relation(originalRelation);
    237                                         List<RelationMember> modifiedMembers = new ArrayList<>();
    238                                         // add stops of a public transport route first:
    239                                         for (RelationMember rm : originalRelation.getMembers()) {
    240                                                 if (RouteUtils.isPTStop(rm)) {
    241                                                         if (rm.hasRole("stop_position")) {
    242                                                                 // it is not expected that stop_positions could be relations
    243                                                                 if (rm.getType().equals(OsmPrimitiveType.NODE)) {
    244                                                                         RelationMember modifiedMember = new RelationMember("stop", rm.getNode());
    245                                                                         modifiedMembers.add(modifiedMember);
    246                                                                 } else { // if it is a primitive of type "way":
    247                                                                         RelationMember modifiedMember = new RelationMember("stop", rm.getWay());
    248                                                                         modifiedMembers.add(modifiedMember);
    249                                                                 }
    250                                                         } else {
    251                                                                 modifiedMembers.add(rm);
    252                                                         }
    253 
    254                                                 }
    255 
    256                                         }
    257                                         // add ways of a public transport route (if they are not
    258                                         // overshoots):
    259                                         for (RelationMember rm : originalRelation.getMembers()) {
    260                                                 if (RouteUtils.isPTWay(rm) && !overshootList.contains(rm)) {           
    261                                                        
    262                                                         if (rm.getRole().equals("")) {
    263                                                                 modifiedMembers.add(rm);
    264                                                         } else {
    265                                                                 RelationMember modifiedMember = new RelationMember("", rm.getWay());
    266                                                                 modifiedMembers.add(modifiedMember);
    267                                                         }
    268                                                 }
    269                                         }
    270                                         modifiedRelation.setMembers(modifiedMembers);
    271 
    272                                         ChangeCommand changeCommand = new ChangeCommand(originalRelation, modifiedRelation);
    273                                         commands.add(changeCommand);
    274                                 }
    275 
    276                         }
     252//                      if (testError.getCode() == ERROR_CODE_OVERSHOOT) {
     253//
     254//                              for (OsmPrimitive primitive : testError.getPrimitives()) {
     255//                                      Relation originalRelation = (Relation) primitive;
     256//                                      Relation modifiedRelation = new Relation(originalRelation);
     257//                                      List<RelationMember> modifiedMembers = new ArrayList<>();
     258//                                      // add stops of a public transport route first:
     259//                                      for (RelationMember rm : originalRelation.getMembers()) {
     260//                                              if (RouteUtils.isPTStop(rm)) {
     261//                                                      if (rm.hasRole("stop_position")) {
     262//                                                              // it is not expected that stop_positions could
     263//                                                              // be relations
     264//                                                              if (rm.getType().equals(OsmPrimitiveType.NODE)) {
     265//                                                                      RelationMember modifiedMember = new RelationMember("stop", rm.getNode());
     266//                                                                      modifiedMembers.add(modifiedMember);
     267//                                                              } else { // if it is a primitive of type "way":
     268//                                                                      RelationMember modifiedMember = new RelationMember("stop", rm.getWay());
     269//                                                                      modifiedMembers.add(modifiedMember);
     270//                                                              }
     271//                                                      } else {
     272//                                                              modifiedMembers.add(rm);
     273//                                                      }
     274//
     275//                                              }
     276//
     277//                                      }
     278//                                      // add ways of a public transport route (if they are not
     279//                                      // overshoots):
     280//                                      for (RelationMember rm : originalRelation.getMembers()) {
     281//                                              if (RouteUtils.isPTWay(rm) && !overshootList.contains(rm)) {
     282//
     283//                                                      if (rm.getRole().equals("")) {
     284//                                                              modifiedMembers.add(rm);
     285//                                                      } else {
     286//                                                              RelationMember modifiedMember = new RelationMember("", rm.getWay());
     287//                                                              modifiedMembers.add(modifiedMember);
     288//                                                      }
     289//                                              }
     290//                                      }
     291//                                      modifiedRelation.setMembers(modifiedMembers);
     292//
     293//                                      ChangeCommand changeCommand = new ChangeCommand(originalRelation, modifiedRelation);
     294//                                      commands.add(changeCommand);
     295//                              }
     296//
     297//                      }
    277298                }
    278299
    … …  
    294315        @Override
    295316        public boolean isFixable(TestError testError) {
    296                 if (testError.getCode() == ERROR_CODE_SORTING || testError.getCode() == ERROR_CODE_OVERSHOOT) {
     317                if (testError.getCode() == ERROR_CODE_SORTING ) {
    297318                        return true;
    298319                }

  • applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/PlatformsFirstTest.java

    r32209 r32230  
    1111import org.openstreetmap.josm.data.validation.Test;
    1212import org.openstreetmap.josm.data.validation.TestError;
     13import org.openstreetmap.josm.plugins.pt_assistant.utils.RouteUtils;
    1314
    14 public class PlatformsFirstTest extends Test { 
    15        
     15public class PlatformsFirstTest extends Test {
     16
    1617        public static final int ERROR_CODE = 3701;
    17        
    18     /**
    19      * Constructs a new {@code InternetTags} test.
    20      */
    21     public PlatformsFirstTest() {
    22         super(tr("Platforms first"), tr("Checks if platforms are listed before ways in the route relation."));
    23     }
    24    
    25     @Override
    26     public void visit(Relation r) {
    27        
    28         if (r.hasKey("route")) {
    2918
    30                 List<RelationMember> members = r.getMembers();
    31                 RelationMember prevMember = null;
    32                 for (RelationMember currMember: members) {
    33                         if (prevMember != null) {
    34                                 // check if the current member is a platform, while the previous member is a way:
    35                                 if (currMember.hasRole("platform") && prevMember.getType().equals(OsmPrimitiveType.WAY) && prevMember.hasRole("")) {
    36                                         this.errors.add(new TestError(this, Severity.WARNING, tr("PT: route relation(s) contain(s) way(s) before platform(s) in the members list"), ERROR_CODE, r));
    37                                         return;
    38                                 }
    39                         }
    40                         prevMember = currMember;
    41                 }
    42         }
    43     }
     19        /**
     20         * Constructs a new {@code InternetTags} test.
     21         */
     22        public PlatformsFirstTest() {
     23                super(tr("Platforms first"), tr("Checks if platforms are listed before ways in the route relation."));
     24        }
     25
     26        @Override
     27        public void visit(Relation r) {
     28
     29                if (RouteUtils.isTwoDirectionRoute(r)) {
     30
     31                        List<RelationMember> members = r.getMembers();
     32                        RelationMember prevMember = null;
     33                        for (RelationMember currMember : members) {
     34                                if (prevMember != null) {
     35                                        // check if the current member is a platform, while the
     36                                        // previous member is a way:
     37                                        if (currMember.hasRole("platform") && prevMember.getType().equals(OsmPrimitiveType.WAY)
     38                                                        && prevMember.hasRole("")) {
     39                                                this.errors.add(new TestError(this, Severity.WARNING,
     40                                                                tr("PT: route relation(s) contain(s) way(s) before platform(s) in the members list"),
     41                                                                ERROR_CODE, r));
     42                                                return;
     43                                        }
     44                                }
     45                                prevMember = currMember;
     46                        }
     47                }
     48        }
    4449}

  • applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/RoadTypeTest.java

    r32226 r32230  
    3131        public void visit(Relation r) {
    3232
    33                 if (RouteUtils.isTwoDirectionRoute(r)) {
    34                        
    35                         List<RelationMember> members = r.getMembers();
     33                if (!RouteUtils.isTwoDirectionRoute(r)) {
     34                        return;
     35                }
    3636
    37                         for (RelationMember rm : members) {
    38                                 if (RouteUtils.isPTWay(rm)) {
    39                                        
    40                                         Way way = rm.getWay();
    41                                         // at this point, the relation has already been checked to
    42                                         // be a route of public_transport:version 2
    43                                         boolean isCorrectRoadType = true;
    44                                         if (r.hasTag("route", "bus") || r.hasTag("route", "share_taxi")) {
    45                                                 if (way.getId()==388339788 || way.getId() == 388339789) {
     37//              boolean isComplete = RouteUtils.ensureMemberCompleteness(r);
     38//              if (!isComplete) {
     39//                      return;
     40//              }
     41               
     42                if (RouteUtils.hasIncompleteMembers(r)) {
     43                        return;
     44                }
     45               
     46                List<RelationMember> members = r.getMembers();
    4647
    47                                                 }
    48                                                 if (!RouteUtils.isWaySuitableForBuses(way)) {
    49                                                         isCorrectRoadType = false;
    50                                                 }
    51                                         } else if (r.hasTag("route", "trolleybus")) {
    52                                                 if (!(RouteUtils.isWaySuitableForBuses(way) && way.hasTag("trolley_wire", "yes"))) {
    53                                                         isCorrectRoadType = false;
    54                                                 }
    55                                         } else if (r.hasTag("route", "tram")) {
    56                                                 if (!r.hasTag("railway", "tram")) {
    57                                                         isCorrectRoadType = false;
    58                                                 }
    59                                         } else if (r.hasTag("route", "subway")) {
    60                                                 if (!r.hasTag("railway", "subway")) {
    61                                                         isCorrectRoadType = false;
    62                                                 }
    63                                         } else if (r.hasTag("route", "light_rail")) {
    64                                                 if (!r.hasTag("raiilway", "subway")) {
    65                                                         isCorrectRoadType = false;
    66                                                 }
    67                                         } else if (r.hasTag("route", "light_rail")) {
    68                                                 if (!r.hasTag("railway", "light_rail")) {
    69                                                         isCorrectRoadType = false;
    70                                                 }
    71                                         } else if (r.hasTag("route", "train")) {
    72                                                 if (!r.hasTag("railway", "train")) {
    73                                                         isCorrectRoadType = false;
    74                                                 }
     48                for (RelationMember rm : members) {
     49                        if (RouteUtils.isPTWay(rm)) {
     50
     51                                Way way = rm.getWay();
     52                                // at this point, the relation has already been checked to
     53                                // be a route of public_transport:version 2
     54                                boolean isCorrectRoadType = true;
     55                                if (r.hasTag("route", "bus") || r.hasTag("route", "share_taxi")) {
     56                                        if (!RouteUtils.isWaySuitableForBuses(way)) {
     57                                                isCorrectRoadType = false;
    7558                                        }
     59                                } else if (r.hasTag("route", "trolleybus")) {
     60                                        if (!(RouteUtils.isWaySuitableForBuses(way) && way.hasTag("trolley_wire", "yes"))) {
     61                                                isCorrectRoadType = false;
     62                                        }
     63                                } else if (r.hasTag("route", "tram")) {
     64                                        if (!r.hasTag("railway", "tram")) {
     65                                                isCorrectRoadType = false;
     66                                        }
     67                                } else if (r.hasTag("route", "subway")) {
     68                                        if (!r.hasTag("railway", "subway")) {
     69                                                isCorrectRoadType = false;
     70                                        }
     71                                } else if (r.hasTag("route", "light_rail")) {
     72                                        if (!r.hasTag("raiilway", "subway")) {
     73                                                isCorrectRoadType = false;
     74                                        }
     75                                } else if (r.hasTag("route", "light_rail")) {
     76                                        if (!r.hasTag("railway", "light_rail")) {
     77                                                isCorrectRoadType = false;
     78                                        }
     79                                } else if (r.hasTag("route", "train")) {
     80                                        if (!r.hasTag("railway", "train")) {
     81                                                isCorrectRoadType = false;
     82                                        }
     83                                }
    7684
    77                                         if (!isCorrectRoadType) {
    78                                                
    79                                                 List<OsmPrimitive> primitiveList = new ArrayList<>(2);
    80                                                 primitiveList.add(0, r);
    81                                                 primitiveList.add(1, way);
    82                                                
    83                                                 errors.add(new TestError(this, Severity.WARNING,
    84                                                                 tr("PT: Route type does not match the type of the road it passes on"),
    85                                                                 ERROR_CODE_ROAD_TYPE, primitiveList));
    86                                         }
     85                                if (!isCorrectRoadType) {
    8786
     87                                        List<Relation> primitives = new ArrayList<>(1);
     88                                        primitives.add(r);
     89                                        List<Way> highlighted = new ArrayList<>(1);
     90                                        highlighted.add(way);
     91                                        errors.add(new TestError(this, Severity.WARNING,
     92                                                        tr("PT: Route type does not match the type of the road it passes on"), ERROR_CODE_ROAD_TYPE,
     93                                                        primitives, highlighted));
    8894                                }
     95
    8996                        }
    9097                }
     98
    9199        }
    92100
    … …  
    97105
    98106                if (testError.getTester().getClass().equals(RoadTypeTest.class) && testError.isFixable()) {
    99                         List<OsmPrimitive> primitiveList = (List<OsmPrimitive>) testError.getPrimitives();
    100                         Relation originalRelation = (Relation) primitiveList.get(0);
    101                         Way wayToRemove = (Way) primitiveList.get(1);
    102                        
     107                        List<OsmPrimitive> primitives = (List<OsmPrimitive>) testError.getPrimitives();
     108                        Relation originalRelation = (Relation) primitives.get(0);
     109                        List<OsmPrimitive> highlighted = (List<OsmPrimitive>) testError.getHighlighted();
     110                        Way wayToRemove = (Way) highlighted.get(0);
     111
    103112                        Relation modifiedRelation = new Relation(originalRelation);
    104                         List<RelationMember> modifiedRelationMembers = new ArrayList<>(originalRelation.getMembersCount()-1);
    105                        
     113                        List<RelationMember> modifiedRelationMembers = new ArrayList<>(originalRelation.getMembersCount() - 1);
     114
    106115                        // copy PT stops first, PT ways last:
    107                         for (RelationMember rm: originalRelation.getMembers()) {
     116                        for (RelationMember rm : originalRelation.getMembers()) {
    108117                                if (RouteUtils.isPTStop(rm)) {
    109                                        
     118
    110119                                        if (rm.getRole().equals("stop_position")) {
    111120                                                if (rm.getType().equals(OsmPrimitiveType.NODE)) {
    … …  
    116125                                                        modifiedRelationMembers.add(newMember);
    117126                                                }
    118                                         } else {
    119                                                 // if the relation member does not have the role "stop_position":
     127                                        } else {
     128                                                // if the relation member does not have the role
     129                                                // "stop_position":
    120130                                                modifiedRelationMembers.add(rm);
    121131                                        }
    122                                        
    123                                 } 
     132
     133                                }
    124134                        }
    125                        
     135
    126136                        // now copy PT ways:
    127                         for (RelationMember rm: originalRelation.getMembers()) {
     137                        for (RelationMember rm : originalRelation.getMembers()) {
    128138                                if (RouteUtils.isPTWay(rm)) {
    129139                                        Way wayToCheck = rm.getWay();
    … …  
    138148                                }
    139149                        }
    140                        
     150
    141151                        modifiedRelation.setMembers(modifiedRelationMembers);
    142                        
     152
    143153                        ChangeCommand changeCommand = new ChangeCommand(originalRelation, modifiedRelation);
    144154                        commands.add(changeCommand);
    145                        
     155
    146156                }
    147                
     157
    148158                if (commands.isEmpty()) {
    149159                        return null;
    … …  
    153163                        return commands.get(0);
    154164                }
    155                
    156165
    157                 return new SequenceCommand(tr("Remove way from route if it does not match the route type"), commands); 
    158                
     166                return new SequenceCommand(tr("Remove way from route if it does not match the route type"), commands);
     167
    159168        }
    160169
    … …  
    167176                        return true;
    168177                }
    169                 return false; 
     178                return false;
    170179        }
    171180
Note: See TracChangeset for help on using the changeset viewer.