[josm-dev] Validator patch for overlapping ways

[Dave Hansen]

On Wed, 2008-05-21 at 20:34 +1000, Roy Rankin wrote:
> I have submitted a patch to TRAC, ticket 774. The following is from
> the 
> report:

Could you post here, too?

I've been doing some hacking on it as well, to the same end.  I also
added the ability to fix a small class of these overlapping ways in an
automated fashion.

If you post your patch, I'll give it a shot the next time I bring up
JOSM.  We really need to get this stuff integrated.

--- OverlappingWays.java	(revision 7656)
+++ OverlappingWays.java	(working copy)
@@ -2,10 +2,11 @@
 
 import static org.openstreetmap.josm.tools.I18n.tr;
 
+import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
-import java.util.ArrayList;
 
-import org.openstreetmap.josm.data.coor.LatLon;
+import org.openstreetmap.josm.command.*;
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
 import org.openstreetmap.josm.data.osm.Way;
 import org.openstreetmap.josm.data.osm.WaySegment;
@@ -44,36 +45,124 @@
 		nodePairs = new Bag<Pair<Node,Node>, WaySegment>(1000);
 	}
 
+    @Override
+    public Command fixError(TestError testError)
+    {
+		Way w1 = (Way)testError.getPrimitives().get(0); 
+		Way w2 = (Way)testError.getPrimitives().get(1); 
+        
+		Collection<OsmPrimitive> primitives = new ArrayList<OsmPrimitive>();;
+		// we want to delete the smaller one
+		if (w1.nodes.size() >= w2.nodes.size())
+			primitives.add(w2);
+		else
+			primitives.add(w1);
+
+        List<Command> cmds = new ArrayList<Command>();
+        cmds.add(new DeleteCommand(primitives));
+       	return new SequenceCommand(tr("Delete Ways"), cmds);
+    }
+
+	public boolean isSubWay(Way little, Way big)
+	{
+		if (little.nodes.size() > big.nodes.size()) {
+			//System.out.println("can not be subway, little>big");
+			return false;
+		}
+		/*
+		for ( Node n : little.nodes )
+			System.out.println("little node: " + (n == little.nodes.get(0)));
+		for ( Node n : big.nodes )
+			System.out.println("big node: " + (n == big.nodes.get(0)));
+	
+		System.out.println("little.nodes.size(): " + little.nodes.size());
+		System.out.println("big.nodes.size(): " + big.nodes.size());
+		*/
+		ArrayList<Pair<Node,Node>> little_pairs = little.getNodePairs(true);
+		ArrayList<Pair<Node,Node>> big_pairs = big.getNodePairs(true);
+
+		Pair<Node,Node> first_little_pair = little_pairs.get(0);
+		int start_at = big_pairs.indexOf(first_little_pair);
+		if (start_at == -1) {
+			System.out.println("can not be subway, no index for flp");
+			return false;
+		}
+		Pair<Node,Node> last_little_pair = little_pairs.get(little_pairs.size()-1);
+		int end_at = big_pairs.indexOf(last_little_pair);
+		if (end_at == -1) {
+			System.out.println("can not be subway, no index for llp");
+			return false;
+		}
+		if (start_at > end_at) {
+				int tmp = start_at;
+				start_at = end_at;
+				end_at = tmp;
+		}
+		// subList's second argument is exlcusive, so +1
+		end_at++;
+		//System.out.println("start_at: " + start_at);
+		//System.out.println("end_at: " + end_at);
+		List<Pair<Node,Node>> big_sub_list = big_pairs.subList(start_at, end_at);
+		//System.out.println("big_sub_list size: " + big_sub_list.size());
+		//System.out.println("little_pairs size: " + little_pairs.size());
+
+		int last_index = 0;
+		for (Pair<Node,Node> pair : little_pairs) {
+			if (big_sub_list.indexOf(pair) != last_index) {
+				System.out.println("can not be subway, non-sequential pairs at: " +
+								last_index + " but found at: " +
+								big_sub_list.indexOf(pair));
+				return false;
+			}
+			last_index++;
+		}
+		if (last_index < little_pairs.size()) {
+				System.out.println("can not be subway, not right length: " + last_index + " vs. " + little_pairs.size());
+				return false;
+		}
+		return true;
+	}
+
+    @Override
+    public boolean isFixable(TestError testError)
+    {
+		Way w1 = (Way)testError.getPrimitives().get(0);
+		Way w2 = (Way)testError.getPrimitives().get(1);
+		Way small;
+		Way large;
+
+		if (w1.nodes.size() >= w2.nodes.size()) {
+			small = w2;
+			large = w1;
+		} else {
+			small = w1;
+			large = w2;
+		}
+		return isSubWay(small, large);
+    }
+
 	@Override
 	public void endTest() 
 	{
-		for (List<WaySegment> duplicated : nodePairs.values())
-		{
-			if (duplicated.size() > 1)
-			{
-				List<OsmPrimitive> prims = new ArrayList<OsmPrimitive>();
-				for (WaySegment ws : duplicated) prims.add(ws.way);
-				errors.add(new TestError(this, Severity.OTHER,
-					tr("Overlapping ways"), prims, duplicated));
-			}
+		for (Pair<Node,Node> pair : nodePairs.keySet()) {
+			List<WaySegment> segments = nodePairs.get(pair);
+			//in.debug("Segsize: " + segments.size());
+			if (segments.size() == 1)
+				continue;
+			List<Way> ways = new ArrayList<Way>();
+			for (WaySegment s : segments)
+				ways.add(s.way);
+			errors.add(new TestError(this, Severity.WARNING, tr("Overlapping ways a"), ways));
 		}
-		nodePairs = null;
 	}
 
 	@Override
 	public void visit(Way w) 
 	{
-		Node lastN = null;
-		int i = -2;
-		for (Node n : w.nodes) {
-			i++;
-			if (lastN == null) {
-				lastN = n;
-				continue;
-			}
-			nodePairs.add(Pair.sort(new Pair<Node,Node>(lastN, n)),
-				new WaySegment(w, i));
-			lastN = n;
+		int i = 0;
+		for (Pair<Node,Node> pair : w.getNodePairs(true)) {
+			//Main.debug("node pair: " + pair.a.id + " " + pair.b.id);
+			nodePairs.add(pair,	new WaySegment(w, i++));
 		}
 	}
 }


-- Dave