Changeset 16200 in josm for trunk/src

Timestamp:

2020-03-24T07:37:08+01:00 (4 years ago)

Author:

GerdP

Message:

see #18863 split ways: false positive warnings about missing members
Solution for the problem case given in the unit test looks OK.
Ticket mentiones two problems, so I am not sure if both are fixed now.

File:

• trunk/src/org/openstreetmap/josm/command/SplitWayCommand.java (modified) (1 diff)

trunk/src/org/openstreetmap/josm/command/SplitWayCommand.java

@@ -501 +501 @@
                                 direction = Direction.IRRELEVANT;
                             } else {
+                                boolean previousWayMemberMissing = true;
+                                boolean nextWayMemberMissing = true;
+
                                 // For ordered relations, looking beyond the nearest neighbour members is not required,
                                 // and can even cause the wrong direction to be guessed (with closed loops).
                                 if (ir - 1 >= 0 && relationMembers.get(ir - 1).isWay()) {
                                     Way w = relationMembers.get(ir - 1).getWay();
-                                    if (w.lastNode() == way.firstNode() || w.firstNode() == way.firstNode()) {
-                                        direction = Direction.FORWARDS;
-                                    } else if (w.firstNode() == way.lastNode() || w.lastNode() == way.lastNode()) {
-                                        direction = Direction.BACKWARDS;
+                                    if (!w.isIncomplete()) {
+                                        previousWayMemberMissing = false;
+                                        if (w.lastNode() == way.firstNode() || w.firstNode() == way.firstNode()) {
+                                            direction = Direction.FORWARDS;
+                                        } else if (w.firstNode() == way.lastNode() || w.lastNode() == way.lastNode()) {
+                                            direction = Direction.BACKWARDS;
+                                        }
                                     }
+                                } else {
+                                    previousWayMemberMissing = false;
                                 }
                                 if (ir + 1 < relationMembers.size() && relationMembers.get(ir + 1).isWay()) {
                                     Way w = relationMembers.get(ir + 1).getWay();
-                                    if (w.lastNode() == way.firstNode() || w.firstNode() == way.firstNode()) {
-                                        direction = Direction.BACKWARDS;
-                                    } else if (w.firstNode() == way.lastNode() || w.lastNode() == way.lastNode()) {
-                                        direction = Direction.FORWARDS;
+                                    if (!w.isIncomplete()) {
+                                        nextWayMemberMissing = false;
+                                        if (w.lastNode() == way.firstNode() || w.firstNode() == way.firstNode()) {
+                                            direction = Direction.BACKWARDS;
+                                        } else if (w.firstNode() == way.lastNode() || w.lastNode() == way.lastNode()) {
+                                            direction = Direction.FORWARDS;
+                                        }
                                     }
+                                } else {
+                                    nextWayMemberMissing = false;
+                                }
+
+                                if (direction == Direction.UNKNOWN
+                                        && !previousWayMemberMissing
+                                        && !nextWayMemberMissing) {
+                                    // If both the next and previous way member in the relation are already known at
+                                    // this point, and they are not connected to this one, then we can safely
+                                    // assume that the direction doesn't matter. Downloading any more members
+                                    // won't help in any case.
+                                    direction = Direction.IRRELEVANT;
                                 }
                             }