diff --git a/data_nodist/relation_analysis.osm b/data_nodist/relation_analysis.osm
new file mode 100644
index 0000000..623e073
--- /dev/null
+++ b/data_nodist/relation_analysis.osm
@@ -0,0 +1,1787 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/org/openstreetmap/josm/gui/dialogs/relation/MemberTableLinkedCellRenderer.java b/src/org/openstreetmap/josm/gui/dialogs/relation/MemberTableLinkedCellRenderer.java
index 6a25ec7..9b3e784 100644
--- a/src/org/openstreetmap/josm/gui/dialogs/relation/MemberTableLinkedCellRenderer.java
+++ b/src/org/openstreetmap/josm/gui/dialogs/relation/MemberTableLinkedCellRenderer.java
@@ -1,9 +1,11 @@
// License: GPL. For details, see LICENSE file.
package org.openstreetmap.josm.gui.dialogs.relation;
+import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Component;
import java.awt.Graphics;
+import java.awt.Graphics2D;
import java.awt.Image;
import javax.swing.JTable;
@@ -39,7 +41,11 @@ public class MemberTableLinkedCellRenderer extends MemberTableCellRenderer {
return;
int ymax=this.getSize().height - 1;
- int xloop = 8;
+ int xloop = 10;
+ int xowloop = 0;
+ if(value.isOnewayLoopForwardPart) xowloop = -3;
+ if(value.isOnewayLoopBackwardPart) xowloop = 3;
+
int xoff = this.getSize().width / 2;
if (value.isLoop) {
xoff -= xloop / 2 - 1;
@@ -51,7 +57,10 @@ public class MemberTableLinkedCellRenderer extends MemberTableCellRenderer {
if (value.linkPrev) {
g.setColor(Color.black);
- g.fillRect(xoff - 1, 0, 3, 1);
+ if(value.isOnewayHead)
+ g.fillRect(xoff - 1, 0, 3, 1);
+ else
+ g.fillRect(xoff - 1 + xowloop, 0, 3, 1);
y1 = 0;
} else {
if (value.isLoop) {
@@ -63,14 +72,20 @@ public class MemberTableLinkedCellRenderer extends MemberTableCellRenderer {
}
else {
g.setColor(Color.red);
- g.drawRect(xoff-1, p - 1 - w, w, w);
+ if(value.isOnewayHead)
+ g.drawRect(xoff-1, p - 3 - w, w, w);
+ else
+ g.drawRect(xoff-1 + xowloop, p - 1 - w, w, w);
y1 = p;
}
}
if (value.linkNext) {
g.setColor(Color.black);
- g.fillRect(xoff - 1, ymax, 3, 1);
+ if(value.isOnewayTail)
+ g.fillRect(xoff - 1, ymax, 3, 1);
+ else
+ g.fillRect(xoff - 1 + xowloop, ymax, 3, 1);
y2 = ymax;
} else {
if (value.isLoop) {
@@ -83,18 +98,54 @@ public class MemberTableLinkedCellRenderer extends MemberTableCellRenderer {
}
else {
g.setColor(Color.red);
- g.drawRect(xoff-1, ymax - p + 1, w, w);
+ if(value.isOnewayTail)
+ g.drawRect(xoff-1, ymax - p + 3, w, w);
+ else
+ g.drawRect(xoff-1 + xowloop, ymax - p + 1, w, w);
y2 = ymax - p;
}
}
/* vertical lines */
g.setColor(Color.black);
- g.drawLine(xoff, y1, xoff, y2);
if (value.isLoop) {
g.drawLine(xoff+xloop, y1, xoff+xloop, y2);
}
+ if (value.isOnewayHead) {
+ setDotted(g);
+ y1 = 7;
+
+ int xValues [] = {xoff - xowloop + 1, xoff - xowloop + 1, xoff};
+ int yValues [] = {ymax, y1+1, 1};
+ g.drawPolyline(xValues, yValues, 3);
+ unsetDotted(g);
+ g.drawLine(xoff + xowloop, y1+1, xoff, 1);
+ }
+
+ if(value.isOnewayTail){
+ setDotted(g);
+ y2 = ymax - 7;
+
+ int xValues [] = {xoff+1, xoff - xowloop + 1, xoff - xowloop + 1};
+ int yValues [] = {ymax-1, y2, y1};
+ g.drawPolyline(xValues, yValues, 3);
+ unsetDotted(g);
+ g.drawLine(xoff + xowloop, y2, xoff, ymax-1);
+ }
+
+ if ((value.isOnewayLoopForwardPart || value.isOnewayLoopBackwardPart) && !value.isOnewayTail && !value.isOnewayHead) {
+ setDotted(g);
+ g.drawLine(xoff - xowloop+1, y1, xoff - xowloop+1, y2 + 1);
+ unsetDotted(g);
+ }
+
+ if (!value.isOnewayLoopForwardPart && !value.isOnewayLoopBackwardPart){
+ g.drawLine(xoff, y1, xoff, y2);
+ }
+
+ g.drawLine(xoff+xowloop, y1, xoff+xowloop, y2);
+
/* special icons */
Image arrow = null;
switch (value.direction) {
@@ -105,13 +156,40 @@ public class MemberTableLinkedCellRenderer extends MemberTableCellRenderer {
arrow = arrowUp;
break;
}
- if ((arrow != null) && (value.linkPrev || value.linkNext)) {
- g.drawImage(arrow, xoff-3, (y1 + y2) / 2 - 2, null);
- }
- else if (value.direction == Direction.ROUNDABOUT_LEFT) {
+ if (value.direction == Direction.ROUNDABOUT_LEFT) {
g.drawImage(roundabout_left, xoff-6, 1, null);
} else if (value.direction == Direction.ROUNDABOUT_RIGHT) {
g.drawImage(roundabout_right, xoff-6, 1, null);
}
+
+ if (!value.isOnewayLoopForwardPart && !value.isOnewayLoopBackwardPart &&
+ (arrow != null)) {
+ g.drawImage(arrow, xoff-3, (y1 + y2) / 2 - 2, null);
+ }
+
+ if (value.isOnewayLoopBackwardPart && value.isOnewayLoopForwardPart) {
+ if(arrow == arrowDown)
+ arrow = arrowUp;
+ else if (arrow == arrowUp)
+ arrow = arrowDown;
+ }
+
+ if ((arrow != null)) {
+ g.drawImage(arrow, xoff+xowloop-3, (y1 + y2) / 2 - 2, null);
+ }
+ }
+
+ private void setDotted(Graphics g) {
+ ((Graphics2D)g).setStroke(new BasicStroke(
+ 1f,
+ BasicStroke.CAP_BUTT,
+ BasicStroke.CAP_BUTT,
+ 5f,
+ new float[] {1f, 2f},
+ 0f));
+ }
+
+ private void unsetDotted(Graphics g) {
+ ((Graphics2D)g).setStroke(new BasicStroke());
}
}
diff --git a/src/org/openstreetmap/josm/gui/dialogs/relation/MemberTableModel.java b/src/org/openstreetmap/josm/gui/dialogs/relation/MemberTableModel.java
index beb01aa..137e43d 100644
--- a/src/org/openstreetmap/josm/gui/dialogs/relation/MemberTableModel.java
+++ b/src/org/openstreetmap/josm/gui/dialogs/relation/MemberTableModel.java
@@ -1,11 +1,7 @@
// License: GPL. For details, see LICENSE file.
package org.openstreetmap.josm.gui.dialogs.relation;
-import static org.openstreetmap.josm.gui.dialogs.relation.WayConnectionType.Direction.BACKWARD;
-import static org.openstreetmap.josm.gui.dialogs.relation.WayConnectionType.Direction.FORWARD;
-import static org.openstreetmap.josm.gui.dialogs.relation.WayConnectionType.Direction.NONE;
-import static org.openstreetmap.josm.gui.dialogs.relation.WayConnectionType.Direction.ROUNDABOUT_LEFT;
-import static org.openstreetmap.josm.gui.dialogs.relation.WayConnectionType.Direction.ROUNDABOUT_RIGHT;
+import static org.openstreetmap.josm.gui.dialogs.relation.WayConnectionType.Direction.*;
import java.util.ArrayList;
import java.util.Arrays;
@@ -57,6 +53,8 @@ public class MemberTableModel extends AbstractTableModel implements TableModelLi
private CopyOnWriteArrayList listeners;
private OsmDataLayer layer;
+ private final int UNCONNECTED = Integer.MIN_VALUE;
+
/**
* constructor
*/
@@ -786,6 +784,9 @@ public class MemberTableModel extends AbstractTableModel implements TableModelLi
setSelectedMembers(sortedMembers);
}
+ private Direction determineDirection(int ref_i, Direction ref_direction, int k) {
+ return determineDirection(ref_i, ref_direction, k, false);
+ }
/**
* Determines the direction of way k with respect to the way ref_i.
* The way ref_i is assumed to have the direction ref_direction and
@@ -795,17 +796,17 @@ public class MemberTableModel extends AbstractTableModel implements TableModelLi
*
* Else the direction is given as follows:
* Let the relation be a route of oneway streets, and someone travels them in the given order.
- * Direction is FORWARD if it is legel and BACKWARD if it is illegal to do so for the given way.
+ * Direction is FORWARD if it is legal and BACKWARD if it is illegal to do so for the given way.
*
**/
- private Direction determineDirection(int ref_i,Direction ref_direction, int k) {
+ private Direction determineDirection(int ref_i, final Direction ref_direction, int k, boolean reversed) {
if (ref_i < 0 || k < 0 || ref_i >= members.size() || k >= members.size())
return NONE;
if (ref_direction == NONE)
return NONE;
- RelationMember m_ref = members.get(ref_i);
- RelationMember m = members.get(k);
+ final RelationMember m_ref = members.get(ref_i);
+ final RelationMember m = members.get(k);
Way way_ref = null;
Way way = null;
@@ -847,6 +848,19 @@ public class MemberTableModel extends AbstractTableModel implements TableModelLi
if (n == nn)
return roundaboutType(k);
}
+ } else if(isOneway(m)) {
+ if (n == RelationNodeMap.firstOnewayNode(m) && !reversed) {
+ if(isBackward(m))
+ return BACKWARD;
+ else
+ return FORWARD;
+ }
+ if (n == RelationNodeMap.lastOnewayNode(m) && reversed) {
+ if(isBackward(m))
+ return FORWARD;
+ else
+ return BACKWARD;
+ }
} else {
if (n == way.firstNode())
return FORWARD;
@@ -931,80 +945,205 @@ public class MemberTableModel extends AbstractTableModel implements TableModelLi
*/
public void updateLinks() {
connectionType = null;
- ArrayList con = new ArrayList();
+ final List con = new ArrayList();
for (int i=0; i0 && con.get(i-1) != null && con.get(i-1).isValid();
+ wct.direction = NONE;
+
+ if(isOneway(m)){
+ if(lastWct != null && lastWct.isOnewayTail)
+ wct.isOnewayHead = true;
+ if(lastBackwardWay == UNCONNECTED && lastForwardWay == UNCONNECTED){ //Beginning of new oneway
+ wct.isOnewayHead = true;
+ lastForwardWay = i-1;
+ lastBackwardWay = i;
+ onewayBeginning = true;
}
- linkNext = (dir != NONE);
- if (dir == NONE) {
- if (roundaboutType(i) != NONE) {
- dir = roundaboutType(i);
- }
+ }
+
+ if (wct.linkPrev) {
+ if(lastBackwardWay != UNCONNECTED && lastForwardWay != UNCONNECTED) {
+ wct = determineOnewayConnectionType(con, m, i, wct);
+ if(!wct.linkPrev)
+ firstGroupIdx = i;
}
+ if(!isOneway(m)) {
+ wct.direction = determineDirection(i-1, lastWct.direction, i);
+ wct.linkPrev = (wct.direction != NONE);
+ }
+ }
+
+ if (!wct.linkPrev) {
+ wct.direction = determineDirectionOfFirst(i, m);
+ if(isOneway(m)){
+ wct.isOnewayLoopForwardPart = true;
+ lastForwardWay = i;
+ }
}
- con.set(i, new WayConnectionType(linkPrev, linkNext, dir));
+ wct.linkNext = false;
+ if(lastWct != null)
+ lastWct.linkNext = wct.linkPrev;
+ con.set(i, wct);
+ lastWct = wct;
- if (! linkNext) {
- boolean loop;
- if (i == firstGroupIdx) {
- loop = determineDirection(i, FORWARD, i) == FORWARD;
- } else {
- loop = determineDirection(i, dir, firstGroupIdx) == con.get(firstGroupIdx).direction;
- }
- if (loop) {
- for (int j=firstGroupIdx; j <= i; ++j) {
- con.get(j).isLoop = true;
- }
- }
- resetFirstGoupIdx = true;
+ if(!wct.linkPrev) {
+ if(i > 0) makeLoopIfNeeded(con, i-1, firstGroupIdx);
+ firstGroupIdx = i;
}
}
+ makeLoopIfNeeded(con, members.size()-1, firstGroupIdx);
connectionType = con;
// for (int i=0; i con, int beg, boolean backward){
+// int i = beg;
+// while(true){
+// WayConnectionType t = con.get(i--);
+// t.isOnewayOppositeConnected = false;
+// if(backward && t.isOnewayLoopBackwardPart) break;
+// if(!backward && t.isOnewayLoopForwardPart) break;
+// }
+// }
+
+ private static Direction reverse(final Direction dir){
+ if(dir == FORWARD) return BACKWARD;
+ if(dir == BACKWARD) return FORWARD;
+ return dir;
+ }
+
+ private static boolean isBackward(final RelationMember member){
+ return member.getRole().equals("backward");
+ }
+
+ private static boolean isForward(final RelationMember member){
+ return member.getRole().equals("forward");
+ }
+
+ public static boolean isOneway(final RelationMember member){
+ return isForward(member) || isBackward(member);
+ }
+
+ private void makeLoopIfNeeded(final List con, final int i, final int firstGroupIdx) {
+ boolean loop;
+ if (i == firstGroupIdx) { //is primitive loop
+ loop = determineDirection(i, FORWARD, i) == FORWARD;
+ } else {
+ loop = determineDirection(i, con.get(i).direction, firstGroupIdx) == con.get(firstGroupIdx).direction;
+ }
+ if (loop) {
+ for (int j=firstGroupIdx; j <= i; ++j) {
+ con.get(j).isLoop = true;
+ }
+ }
+ }
+
+ private Direction determineDirectionOfFirst(final int i, final RelationMember m) {
+ if (roundaboutType(i) != NONE) {
+ return roundaboutType(i);
+ }
+
+ if (isOneway(m)){
+ if(isBackward(m)) return BACKWARD;
+ else return FORWARD;
+ } else { /** guess the direction and see if it fits with the next member */
+ if(determineDirection(i, FORWARD, i+1) != NONE) return FORWARD;
+ if(determineDirection(i, BACKWARD, i+1) != NONE) return BACKWARD;
+ }
+ return NONE;
+ }
+
+ int lastForwardWay, lastBackwardWay;
+ boolean onewayBeginning;
+ private WayConnectionType determineOnewayConnectionType(final List con,
+ RelationMember m, int i, final WayConnectionType wct) {
+ Direction dirFW = determineDirection(lastForwardWay, con.get(lastForwardWay).direction, i);
+ Direction dirBW = NONE;
+ if(onewayBeginning) {
+ if(lastBackwardWay != i)
+ dirBW = determineDirection(lastBackwardWay, reverse(con.get(lastBackwardWay).direction), i, true);
+ if(dirBW != NONE)
+ onewayBeginning = false;
+ } else
+ dirBW = determineDirection(lastBackwardWay, con.get(lastBackwardWay).direction, i, true);
+
+ if(isOneway(m)) {
+ if(dirBW != NONE){
+ wct.direction = dirBW;
+ lastBackwardWay = i;
+ wct.isOnewayLoopBackwardPart = true;
+ }
+ if(dirFW != NONE){
+ wct.direction = dirFW;
+ lastForwardWay = i;
+ wct.isOnewayLoopForwardPart = true;
+ }
+ if(dirFW == NONE && dirBW == NONE) { //Not connected to previous
+// unconnectPreviousLink(con, i, true);
+// unconnectPreviousLink(con, i, false);
+ wct.linkPrev = false;
+ if(isOneway(m)){
+ wct.isOnewayHead = true;
+ lastForwardWay = i-1;
+ lastBackwardWay = i;
+ } else {
+ lastForwardWay = UNCONNECTED;
+ lastBackwardWay = UNCONNECTED;
+ }
+ onewayBeginning = true;
+ }
+
+ if(dirFW != NONE && dirBW != NONE) { //End of oneway loop
+ if(i+1> nodes = new TreeMap>();
+ public Map> ways = new TreeMap>();
+ public boolean oneWay;
+ public NodesWays(boolean oneWay){
+ this.oneWay = oneWay;
+ }
+ }
+
/*
* the maps. (Need TreeMap for efficiency.)
*/
- private TreeMap> nodesMap;
- private TreeMap> waysMap;
+ private NodesWays map = new NodesWays(false);
+ /*
+ * Maps for oneways (forward/backward roles)
+ */
+
+ private NodesWays onewayMap = new NodesWays(true);
+ private NodesWays onewayReverseMap = new NodesWays(true);
/*
* Used to keep track of what members are done.
*/
- private TreeSet remaining;
+ private Set remaining;
+ private Map> remainingOneway = new TreeMap>();;
/**
* All members that are incomplete or not a way
*/
private List notSortable = new ArrayList();
+ public static Node firstOnewayNode(RelationMember m){
+ if(!m.isWay()) return null;
+ if(m.getRole().equals("backward")) return m.getWay().lastNode();
+ return m.getWay().firstNode();
+ }
+
+ public static Node lastOnewayNode(RelationMember m){
+ if(!m.isWay()) return null;
+ if(m.getRole().equals("backward")) return m.getWay().firstNode();
+ return m.getWay().lastNode();
+ }
+
RelationNodeMap(List members) {
- nodesMap = new TreeMap>();
- waysMap = new TreeMap>();
+ map.nodes = new TreeMap>();
+ map.ways = new TreeMap>();
for (int i = 0; i < members.size(); ++i) {
RelationMember m = members.get(i);
- if (m.getMember().isIncomplete() || !m.isWay())
- {
+ if (m.getMember().isIncomplete() || !m.isWay()) {
notSortable.add(i);
+ continue;
}
- else {
- Way w = m.getWay();
- if (MemberTableModel.roundaboutType(w) != NONE) {
- for (Node nd : w.getNodes()) {
- addPair(nd, i);
- }
- } else {
- addPair(w.firstNode(), i);
- addPair(w.lastNode(), i);
+
+ Way w = m.getWay();
+ if ((MemberTableModel.roundaboutType(w) != NONE)) {
+ for (Node nd : w.getNodes()) {
+ addPair(nd, i);
}
+ } else if(MemberTableModel.isOneway(m)) {
+ addNodeWayMap(firstOnewayNode(m), i);
+ addWayNodeMap(lastOnewayNode(m), i);
+ addNodeWayMapReverse(lastOnewayNode(m), i);
+ addWayNodeMapReverse(firstOnewayNode(m), i);
+ addRemainingForward(firstOnewayNode(m), i);
+ addRemainingForward(lastOnewayNode(m), i);
+ } else {
+ addPair(w.firstNode(), i);
+ addPair(w.lastNode(), i);
}
}
remaining = new TreeSet();
- for (Integer k : waysMap.keySet()) {
- remaining.add(k);
- }
+ remaining.addAll(map.ways.keySet());
/*
* Clean up the maps, i.e. remove nodes from roundabouts and dead ends that
* cannot be used in future. (only for performance)
*/
- Iterator>> it = nodesMap.entrySet().iterator();
- while (it.hasNext()) {
- Map.Entry> nodeLinks = it.next();
+// Iterator>> it = map.nodes.entrySet().iterator();
+// while (it.hasNext()) {
+// Map.Entry> nodeLinks = it.next();
+//
+// if (nodeLinks.getValue().size() < 2) {
+// if (nodeLinks.getValue().size() != 1) throw new AssertionError();
+//
+// Integer d_way = nodeLinks.getValue().iterator().next();
+// TreeSet d_way_nodes = map.ways.get(d_way);
+// d_way_nodes.remove(nodeLinks.getKey());
+//
+// it.remove();
+// continue;
+// }
+// }
+ }
- if (nodeLinks.getValue().size() < 2) {
- if (nodeLinks.getValue().size() != 1) throw new AssertionError();
+ private void addPair(Node n, int i) {
+ Set ts = map.nodes.get(n);
+ if (ts == null) {
+ ts = new TreeSet();
+ map.nodes.put(n, ts);
+ }
+ ts.add(i);
- Integer d_way = nodeLinks.getValue().iterator().next();
- TreeSet d_way_nodes = waysMap.get(d_way);
- d_way_nodes.remove(nodeLinks.getKey());
+ Set ts2 = map.ways.get(i);
+ if (ts2 == null) {
+ ts2 = new TreeSet();
+ map.ways.put(i, ts2);
+ }
+ ts2.add(n);
+ }
- it.remove();
- continue;
- }
+ private void addNodeWayMap(Node n, int i) {
+ Set ts = onewayMap.nodes.get(n);
+ if (ts == null) {
+ ts = new TreeSet();
+ onewayMap.nodes.put(n, ts);
}
+ ts.add(i);
}
- private void addPair(Node n, int i) {
- TreeSet ts = nodesMap.get(n);
+ private void addWayNodeMap(Node n, int i) {
+ Set ts2 = onewayMap.ways.get(i);
+ if (ts2 == null) {
+ ts2 = new TreeSet();
+ onewayMap.ways.put(i, ts2);
+ }
+ ts2.add(n);
+ }
+
+ private void addNodeWayMapReverse(Node n, int i) {
+ Set ts = onewayReverseMap.nodes.get(n);
if (ts == null) {
ts = new TreeSet();
- nodesMap.put(n, ts);
+ onewayReverseMap.nodes.put(n, ts);
}
ts.add(i);
+ }
- TreeSet ts2 = waysMap.get(i);
+ private void addWayNodeMapReverse(Node n, int i) {
+ Set ts2 = onewayReverseMap.ways.get(i);
if (ts2 == null) {
ts2 = new TreeSet();
- waysMap.put(i, ts2);
+ onewayReverseMap.ways.put(i, ts2);
}
ts2.add(n);
}
+ private void addRemainingForward(Node n, int i) {
+ Set ts2 = remainingOneway.get(i);
+ if (ts2 == null) {
+ ts2 = new TreeSet();
+ remainingOneway.put(i, ts2);
+ }
+ ts2.add(n);
+ }
+
+ Integer firstOneway = null;
+ Node lastOnewayNode = null;
+ Node firstCircular = null;
+
/**
* Return a relation member that is linked to the
- * member 'i', but has not been popped jet.
+ * member 'i', but has not been popped yet.
* Return null if there is no such member left.
*/
- public Integer popAdjacent(Integer i) {
- TreeSet nodes = waysMap.get(i);
- for (Node n : nodes) {
- TreeSet adj = nodesMap.get(n);
- if (!adj.isEmpty()) {
- Integer j = adj.iterator().next();
- done(j);
- waysMap.get(j).remove(n);
- return j;
+ public Integer popAdjacent(Integer way) {
+ if (lastOnewayNode != null) return popBackwardOnewayPart(way);
+ if (firstOneway != null) return popForwardOnewayPart(way);
+
+ if (map.ways.containsKey(way)){
+ for (Node n : map.ways.get(way)) {
+ Integer i = deleteAndGetAdjacentNode(map, n);
+ if(i != null) return i;
+
+ Integer j = deleteAndGetAdjacentNode(onewayMap, n);
+ if(j != null) {
+ firstOneway = j;
+ return j;
+ }
+ }
+ }
+
+ firstOneway = way;
+ return popForwardOnewayPart(way);
+ }
+
+ private Integer popForwardOnewayPart(Integer way) {
+ if(onewayMap.ways.containsKey(way)) {
+ for (Node n : onewayMap.ways.get(way)) {
+ Integer i = findAdjacentWay(onewayMap, n);
+ if(i == null) continue;
+
+ lastOnewayNode = processBackwardIfEndOfLoopReached(i);
+ if(lastOnewayNode != null){
+ return popBackwardOnewayPart(firstOneway);
+ }
+
+ deleteWayNode(onewayMap, i, n);
+ return i;
+ }
+ }
+
+ firstOneway = null;
+ return null;
+ }
+
+ private Node processBackwardIfEndOfLoopReached(Integer way) { //find if we didn't reach end of the loop (and process backward part)
+ if (onewayReverseMap.ways.containsKey(way)) {
+ for (Node n : onewayReverseMap.ways.get(way)) {
+ if((map.nodes.containsKey(n))
+ || (onewayMap.nodes.containsKey(n) && onewayMap.nodes.get(n).size() > 1)) {
+ return n;
+ }
+ if(firstCircular != null && firstCircular == n) {
+ return firstCircular;
+ }
+ }
+ }
+ return null;
+ }
+
+ private Integer popBackwardOnewayPart(int way){
+ if (lastOnewayNode != null) {
+ TreeSet nodes = new TreeSet();
+ if (onewayReverseMap.ways.containsKey(way)) nodes.addAll(onewayReverseMap.ways.get(way));
+ if (map.ways.containsKey(way)) nodes.addAll(map.ways.get(way));
+ for (Node n : nodes) {
+ if(n == lastOnewayNode) { //if oneway part ends
+ firstOneway = null;
+ lastOnewayNode = null;
+ Integer j = deleteAndGetAdjacentNode(map, n);
+ if(j != null) return j;
+
+ Integer k = deleteAndGetAdjacentNode(onewayMap, n);
+ if(k != null) {
+ firstOneway = k;
+ return k;
+ }
+ }
+
+ Integer j = deleteAndGetAdjacentNode(onewayReverseMap, n);
+ if(j != null) return j;
}
}
+
+ firstOneway = null;
+ lastOnewayNode = null;
+
return null;
}
/**
+ * find next node in nw NodeWays structure, if the node is found delete and return it
+ * @param nw
+ * @param n
+ * @return node next to n
+ */
+ private Integer deleteAndGetAdjacentNode(NodesWays nw, Node n){
+ Integer j = findAdjacentWay(nw, n);
+ if(j == null) return null;
+ deleteWayNode(nw, j, n);
+ return j;
+ }
+
+ private Integer findAdjacentWay(NodesWays nw, Node n) {
+ Set adj = nw.nodes.get(n);
+ if (adj == null || adj.isEmpty()) return null;
+ Integer j = adj.iterator().next();
+ return j;
+ }
+
+ private void deleteWayNode(NodesWays nw, Integer way, Node n){
+ if(nw.oneWay)
+ doneOneway(way);
+ else
+ done(way);
+ nw.ways.get(way).remove(n);
+ }
+
+ /**
* Returns some remaining member or null if
* every sortable member has been processed.
*/
public Integer pop() {
- if (remaining.isEmpty()) return null;
- Integer i = remaining.iterator().next();
- done(i);
+ if (!remaining.isEmpty()){
+ Integer i = remaining.iterator().next();
+ done(i);
+ return i;
+ }
+
+ if (remainingOneway.isEmpty()) return null;
+ for(Integer i :remainingOneway.keySet()){ //find oneway, whic is connected to more than one way (is between two oneway loops)
+ for(Node n : onewayReverseMap.ways.get(i)){
+ if(onewayReverseMap.nodes.containsKey(n) && onewayReverseMap.nodes.get(n).size() > 1) {
+ doneOneway(i);
+ firstCircular = n;
+ return i;
+ }
+ }
+ }
+
+ Integer i = remainingOneway.keySet().iterator().next();
+ doneOneway(i);
return i;
}
/**
* This relation member has been processed.
- * Remove references in the nodesMap.
+ * Remove references in the map.nodes.
*/
+ private void doneOneway(Integer i) {
+ Set nodesForward = remainingOneway.get(i);
+ for (Node n : nodesForward) {
+ if(onewayMap.nodes.containsKey(n)) onewayMap.nodes.get(n).remove(i);
+ if(onewayReverseMap.nodes.containsKey(n)) onewayReverseMap.nodes.get(n).remove(i);
+ }
+ remainingOneway.remove(i);
+ }
+
private void done(Integer i) {
remaining.remove(i);
- TreeSet nodes = waysMap.get(i);
+ Set nodes = map.ways.get(i);
for (Node n : nodes) {
- boolean result = nodesMap.get(n).remove(i);
+ boolean result = map.nodes.get(n).remove(i);
if (!result) throw new AssertionError();
}
}
diff --git a/src/org/openstreetmap/josm/gui/dialogs/relation/WayConnectionType.java b/src/org/openstreetmap/josm/gui/dialogs/relation/WayConnectionType.java
index 347c722..275669f 100644
--- a/src/org/openstreetmap/josm/gui/dialogs/relation/WayConnectionType.java
+++ b/src/org/openstreetmap/josm/gui/dialogs/relation/WayConnectionType.java
@@ -10,8 +10,8 @@ public class WayConnectionType {
private final boolean invalid;
/** True, if linked to the previous / next member. */
- public final boolean linkPrev;
- public final boolean linkNext;
+ public boolean linkPrev;
+ public boolean linkNext;
/**
* direction is FORWARD if the first node of this way is connected to the previous way
@@ -22,7 +22,7 @@ public class WayConnectionType {
* If there is no connection to the previous or next member, then
* direction has the value NONE.
*/
- public final Direction direction;
+ public Direction direction;
public enum Direction {
FORWARD, BACKWARD, ROUNDABOUT_LEFT, ROUNDABOUT_RIGHT, NONE;
@@ -35,7 +35,11 @@ public class WayConnectionType {
/** True, if the element is part of a closed loop of ways. */
public boolean isLoop;
- public boolean isRoundabout = false;
+ public boolean isOnewayLoopForwardPart = false;
+ public boolean isOnewayLoopBackwardPart = false;
+ public boolean isOnewayHead = false;
+ public boolean isOnewayTail = false;
+// public boolean isOnewayOppositeConnected = true;
public WayConnectionType(boolean linkPrev, boolean linkNext, Direction direction) {
this.linkPrev = linkPrev;
@@ -45,6 +49,10 @@ public class WayConnectionType {
invalid = false;
}
+ public WayConnectionType(boolean invalid){
+ this.invalid = invalid;
+ }
+
/** construct invalid instance */
public WayConnectionType() {
this.linkPrev = false;
@@ -60,7 +68,9 @@ public class WayConnectionType {
@Override
public String toString() {
- return "[P "+linkPrev+" ;N "+linkNext+" ;D "+direction+" ;L "+isLoop+"]";
+ return "[P "+linkPrev+" ;N "+linkNext+" ;D "+direction+" ;L "+isLoop+
+ " ;FP " + isOnewayLoopForwardPart+";BP " + isOnewayLoopBackwardPart+
+ ";OH " + isOnewayHead+";OT " + isOnewayTail+"]";
}
public String getToolTip() {