Changeset 57 in josm

Timestamp:

2006-02-21T13:39:40+01:00 (19 years ago)

Author:

imi

Message:

fixed bug where merged nodes and line segments were equal but not the same (aliasing)

Files:

• src/org/openstreetmap/josm/data/osm/visitor/MergeVisitor.java (modified) (6 diffs)
• src/org/openstreetmap/josm/gui/layer/OsmDataLayer.java (modified) (1 diff)
• test/org/openstreetmap/josm/test/MergeVisitorTest.java (modified) (3 diffs)

src/org/openstreetmap/josm/data/osm/visitor/MergeVisitor.java

@@ -1 +1 @@
 package org.openstreetmap.josm.data.osm.visitor;
 
+import java.util.HashMap;
 import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.Map;
 
 import org.openstreetmap.josm.data.osm.DataSet;
@@ -20 +23 @@
         private final DataSet ds;
         
+        /**
+         * A list of all nodes that got replaced with other nodes.
+         * Key is the node in the other's dataset and the value is the one that is now
+         * in ds.nodes instead.
+         */
+        private final Map<Node, Node> mergedNodes = new HashMap<Node, Node>();
+        /**
+         * A list of all line segments that got replaced with others.
+         * Key is the segment in the other's dataset and the value is the one that is now
+         * in ds.lineSegments.
+         */
+        private final Map<LineSegment, LineSegment> mergedLineSegments = new HashMap<LineSegment, LineSegment>();
+        
         public MergeVisitor(DataSet ds) {
                 this.ds = ds;
@@ -39 +55 @@
                         ds.nodes.add(otherNode);
                 else {
+                        mergedNodes.put(otherNode, myNode);
                         mergeCommon(myNode, otherNode);
                         if (myNode.modified && !otherNode.modified)
@@ -64 +81 @@
                         ds.lineSegments.add(otherLs);
                 else {
+                        mergedLineSegments.put(otherLs, myLs);
                         mergeCommon(myLs, otherLs);
                         if (myLs.modified && !otherLs.modified)
@@ -99 +117 @@
                         Iterator<LineSegment> it = otherTrack.segments.iterator();
                         for (LineSegment ls : myTrack.segments) {
-                                if (!match(ls, it.next())) {
+                                if (!match(ls, it.next()))
                                         same = false;
-                                }
                         }
                         if (!same) {
@@ -113 +130 @@
         public void visit(Key k) {
                 //TODO: Key doesn't really fit the OsmPrimitive concept!
+        }
+        
+        /**
+         * Postprocess the dataset and fix all merged references to point to the actual
+         * data.
+         */
+        public void fixReferences() {
+                for (LineSegment ls : ds.lineSegments) {
+                        if (mergedNodes.containsKey(ls.start))
+                                ls.start = mergedNodes.get(ls.start);
+                        if (mergedNodes.containsKey(ls.end))
+                                ls.end = mergedNodes.get(ls.end);
+                }
+                for (Track t : ds.tracks) {
+                        boolean replacedSomething = false;
+                        LinkedList<LineSegment> newSegments = new LinkedList<LineSegment>();
+                        for (LineSegment ls : t.segments) {
+                                LineSegment otherLs = mergedLineSegments.get(ls);
+                                newSegments.add(otherLs == null ? ls : otherLs);
+                                if (otherLs != null)
+                                        replacedSomething = true;
+                        }
+                        if (replacedSomething) {
+                                t.segments.clear();
+                                t.segments.addAll(newSegments);
+                        }
+                        for (LineSegment ls : t.segments) {
+                                if (mergedNodes.containsKey(ls.start))
+                                        ls.start = mergedNodes.get(ls.start);
+                                if (mergedNodes.containsKey(ls.end))
+                                        ls.end = mergedNodes.get(ls.end);
+                        }
+                }
         }
         

src/org/openstreetmap/josm/gui/layer/OsmDataLayer.java

@@ -136 +136 @@
                 for (OsmPrimitive osm : ((OsmDataLayer)from).data.allPrimitives())
                         osm.visit(visitor);
+                visitor.fixReferences();
         }
 

test/org/openstreetmap/josm/test/MergeVisitorTest.java

@@ -7 +7 @@
 import org.openstreetmap.josm.data.osm.LineSegment;
 import org.openstreetmap.josm.data.osm.Node;
+import org.openstreetmap.josm.data.osm.OsmPrimitive;
 import org.openstreetmap.josm.data.osm.visitor.MergeVisitor;
+import org.openstreetmap.josm.test.framework.Bug;
 import org.openstreetmap.josm.test.framework.DataSetTestCaseHelper;
 
@@ -19 +21 @@
         public void testMergeOldLineSegmentsWithNew() {
                 DataSet ds = new DataSet();
-                Node n1 = DataSetTestCaseHelper.createNode(ds);
-                n1.id = 1;
-                Node n2 = DataSetTestCaseHelper.createNode(ds);
-                n2.id = 2;
-                LineSegment ls1 = DataSetTestCaseHelper.createLineSegment(ds, n1, n2);
+                Node[] n = createNodes(ds, 2);
+                LineSegment ls1 = DataSetTestCaseHelper.createLineSegment(ds, n[0], n[1]);
                 ls1.id = 3;
 
                 Node newnode = new Node();
-                newnode.coor = new GeoPoint(n2.coor.lat, n2.coor.lon);
-                LineSegment newls = new LineSegment(n1, newnode);
+                newnode.coor = new GeoPoint(n[1].coor.lat, n[1].coor.lon);
+                LineSegment newls = new LineSegment(n[0], newnode);
 
                 MergeVisitor v = new MergeVisitor(ds);
@@ -34 +33 @@
                 assertEquals("line segment should have been merged.", 1, ds.lineSegments.size());
         }
+        
+        /**
+         * Nodes beeing merged are equal but not the same.
+         */
+        @Bug(54)
+        public void testEqualNotSame() {
+                // create a dataset with line segment a-b
+                DataSet ds = new DataSet();
+                Node n[] = createNodes(ds, 2);
+                LineSegment ls1 = DataSetTestCaseHelper.createLineSegment(ds, n[0], n[1]);
+                ls1.id = 1;
+                
+                // create an other dataset with line segment a'-c (a' is equal, but not same to a)
+                DataSet ds2 = new DataSet();
+                Node n2[] = createNodes(ds2, 2);
+                n2[0].coor = new GeoPoint(n[0].coor.lat, n[0].coor.lon);
+                n2[1].id = 42;
+                LineSegment ls2 = DataSetTestCaseHelper.createLineSegment(ds, n2[0], n2[1]);
+                
+                MergeVisitor v = new MergeVisitor(ds);
+                for (OsmPrimitive osm : ds2.allPrimitives())
+                        osm.visit(v);
+                v.fixReferences();
+                
+                assertSame(ls1.start, ls2.start);
+        }
+        
+        
+        /**
+         * Create that amount of nodes and add them to the dataset. The id will be 1,2,3,4...
+         * @param amount Number of nodes to create.
+         * @return The created nodes.
+         */
+        private Node[] createNodes(DataSet ds, int amount) {
+                Node[] nodes = new Node[amount];
+                for (int i = 0; i < amount; ++i) {
+                        nodes[i] = DataSetTestCaseHelper.createNode(ds);
+                        nodes[i].id = i+1;
+                }
+                return nodes;
+        }
 }