Changeset 23 in josm for src/org/openstreetmap/josm/data/osm/DataSet.java

Timestamp:

2005-10-27T00:38:03+02:00 (18 years ago)

Author:

imi

Message:

• added commands to support undo later
• added Edit-Layer concept
• painting of deleted objects

File:

• src/org/openstreetmap/josm/data/osm/DataSet.java (moved) (moved from src/org/openstreetmap/josm/command/DataSet.java ) (7 diffs)

src/org/openstreetmap/josm/data/osm/DataSet.java

@@ -1 @@
-package org.openstreetmap.josm.command;
+package org.openstreetmap.josm.data.osm;
 
 import java.util.Collection;
-import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
-import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.Map;
@@ -12 +10 @@
 import org.openstreetmap.josm.data.Bounds;
 import org.openstreetmap.josm.data.SelectionTracker;
-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.Track;
+import org.openstreetmap.josm.data.osm.visitor.AllNodesVisitor;
 
 /**
@@ -41 +36 @@
          * are in this list but are in no track.
          */
-        Collection<LineSegment> pendingLineSegments = new LinkedList<LineSegment>();
+        public Collection<LineSegment> pendingLineSegments = new LinkedList<LineSegment>();
 
         /**
@@ -50 +45 @@
          * track list.
          */
-        Collection<Track> tracks = new LinkedList<Track>();
-
-        /**
-         * Add the track to the tracklist.
-         */
-        public void addTrack(Track t) {
-                tracks.add(t);
-        }
-        /**
-         * Remove the track from the tracklist.
-         */
-        public void removeTrack(Track t) {
-                t.destroy();
-                tracks.remove(t);
-        }
-        /**
-         * Return a read-only collection of all tracks
-         */
-        public Collection<Track> tracks() {
-                return Collections.unmodifiableCollection(tracks);
-        }
-
-        /**
-         * Add a newly created line segment to the pending lines list.
-         */
-        public void addPendingLineSegment(LineSegment ls) {
-                pendingLineSegments.add(ls);
-        }
-        /**
-         * Remove a line segment from the pending lines list, because it has been
-         * assigned to the track.
-         * @param ls The line segment from the pending list
-         * @param t The track, that will hold the line segment
-         * @param end <code>true</code> to attach on the end. <code>false</code>
-         *              to attach on the beginning.
-         */
-        public void assignPendingLineSegment(LineSegment ls, Track t, boolean end) {
-                pendingLineSegments.remove(ls);
-                if (end)
-                        t.add(ls);
-                else
-                        t.addStart(ls);
-        }
-        /**
-         * Delete the pending line segment without moving it anywhere.
-         */
-        public void destroyPendingLineSegment(LineSegment ls) {
-                pendingLineSegments.remove(ls);
-                ls.destroy();
-        }
-        /**
-         * Return an read-only iterator over all pending line segments.
-         */
-        public Collection<LineSegment> pendingLineSegments() {
-                return Collections.unmodifiableCollection(pendingLineSegments);
-        }
-
+        public Collection<Track> tracks = new LinkedList<Track>();
+
+        
+        /**
+         * This is a list of all back references of nodes to their track usage.
+         */
+        public Map<Node, Set<Track>> nodeTrackRef = new HashMap<Node, Set<Track>>();
+        /**
+         * This is a list of all back references of nodes to their line segments.
+         */
+        public Map<Node, Set<LineSegment>> nodeLsRef = new HashMap<Node, Set<LineSegment>>();
+        /**
+         * This is a list of all back references of lines to their tracks.
+         */
+        public Map<LineSegment, Set<Track>> lsTrackRef = new HashMap<LineSegment, Set<Track>>();
+
+        /**
+         * Add a back reference from the node to the line segment.
+         */
+        public void addBackReference(Node from, LineSegment to) {
+                Set<LineSegment> references = nodeLsRef.get(from);
+                if (references == null)
+                        references = new HashSet<LineSegment>();
+                references.add(to);
+                nodeLsRef.put(from, references);
+        }
+        /**
+         * Add a back reference from the node to the track.
+         */
+        public void addBackReference(Node from, Track to) {
+                Set<Track> references = nodeTrackRef.get(from);
+                if (references == null)
+                        references = new HashSet<Track>();
+                references.add(to);
+                nodeTrackRef.put(from, references);
+        }
+        /**
+         * Add a back reference from the line segment to the track.
+         */
+        public void addBackReference(LineSegment from, Track to) {
+                Set<Track> references = lsTrackRef.get(from);
+                if (references == null)
+                        references = new HashSet<Track>();
+                references.add(to);
+                lsTrackRef.put(from, references);
+        }
+
+        /**
+         * Removes all references to and from this line segment.
+         */
+        public void removeBackReference(LineSegment ls) {
+                Set<LineSegment> s = nodeLsRef.get(ls.start);
+                if (s != null)
+                        s.remove(ls);
+                s = nodeLsRef.get(ls.end);
+                if (s != null)
+                        s.remove(ls);
+                lsTrackRef.remove(ls);
+        }
+        /**
+         * Removes all references to and from the node.
+         */
+        public void removeBackReference(Node n) {
+                nodeLsRef.remove(n);
+                nodeTrackRef.remove(n);
+        }
+        /**
+         * Removes all references to and from the track.
+         */
+        public void removeBackReference(Track t) {
+                Collection<Node> nodes = AllNodesVisitor.getAllNodes(t);
+                for (Node n : nodes) {
+                        Set<Track> s = nodeTrackRef.get(n);
+                        if (s != null)
+                                s.remove(t);
+                }
+                for (LineSegment ls : t.segments) {
+                        Set<Track> s = lsTrackRef.get(ls);
+                        if (s != null)
+                                s.remove(t);
+                }
+        }
+        
+        /**
+         * Rebuild the caches of back references.
+         */
+        public void rebuildBackReferences() {
+                nodeTrackRef.clear();
+                nodeLsRef.clear();
+                lsTrackRef.clear();
+                for (Track t : tracks) {
+                        for (LineSegment ls : t.segments) {
+                                addBackReference(ls.start, ls);
+                                addBackReference(ls.end, ls);
+                                addBackReference(ls.start, t);
+                                addBackReference(ls.end, t);
+                                addBackReference(ls, t);
+                        }
+                }
+                for (LineSegment ls : pendingLineSegments) {
+                        addBackReference(ls.start, ls);
+                        addBackReference(ls.end, ls);
+                }
+        }
+        
         /**
          * Return the bounds of this DataSet, depending on X/Y values.
@@ -177 +220 @@
                 clearSelection(tracks);
                 for (Track t : tracks)
-                        clearSelection(t.segments());
+                        clearSelection(t.segments);
         }
 
@@ -190 +233 @@
                 sel.addAll(getSelected(tracks));
                 for (Track t : tracks)
-                        sel.addAll(getSelected(t.segments()));
+                        sel.addAll(getSelected(t.segments));
                 return sel;
         }
@@ -198 +241 @@
          * The objects imported are not cloned, so from now on, these data belong
          * to both datasets. So use mergeFrom only if you are about to abandon the
-         * other dataset or this dataset.
+         * other dataset.
+         * 
+         * Elements are tried to merged. 
+         * Nodes are merged first, if their lat/lon are equal.
+         * Line segments are merged, if they have the same nodes.
+         * Tracs are merged, if they consist of the same line segments.
+         * 
+         * Additional to that, every two objects with the same id are merged.
          * 
          * @param ds    The DataSet to merge into this one.
-         * @param mergeEqualNodes If <code>true</code>, nodes with the same lat/lon
-         *              are merged together.
-         */
-        public void mergeFrom(DataSet ds, boolean mergeEqualNodes) {
-                if (mergeEqualNodes && !nodes.isEmpty()) {
-                        Map<Node, Node> mergeMap = new HashMap<Node, Node>();
-                        Set<Node> nodesToAdd = new HashSet<Node>();
-                        for (Node n : nodes) {
-                                for (Iterator<Node> it = ds.nodes.iterator(); it.hasNext();) {
-                                        Node dsn = it.next();
-                                        if (n.coor.equalsLatLon(dsn.coor)) {
-                                                mergeMap.put(dsn, n);
-                                                n.mergeFrom(dsn);
-                                                it.remove();
-                                        } else {
-                                                nodesToAdd.add(dsn);
-                                        }
+         * @return A list of all primitives that were used in the conjunction. That
+         *              is all used primitives (the merged primitives and all added ones).
+         */
+        public Collection<OsmPrimitive> mergeFrom(DataSet ds) {
+                Collection<OsmPrimitive> data = new LinkedList<OsmPrimitive>();
+
+                Set<LineSegment> myLineSegments = new HashSet<LineSegment>();
+                myLineSegments.addAll(pendingLineSegments);
+                for (Track t : tracks)
+                        myLineSegments.addAll(t.segments);
+                
+                Set<LineSegment> otherLineSegments = new HashSet<LineSegment>();
+                otherLineSegments.addAll(ds.pendingLineSegments);
+                for (Track t : ds.tracks)
+                        otherLineSegments.addAll(t.segments);
+                
+                
+                // merge nodes
+
+                Map<Node, Node> nodeMap = new HashMap<Node, Node>();
+                // find mergable
+                for (Node otherNode : ds.nodes)
+                        for (Node myNode : nodes)
+                                if (otherNode.coor.equalsLatLon(myNode.coor))
+                                        nodeMap.put(otherNode, myNode);
+                // add
+                data.addAll(new HashSet<Node>(nodeMap.values()));
+                for (Node n : ds.nodes) {
+                        if (!nodeMap.containsKey(n)) {
+                                nodes.add(n);
+                                data.add(n);
+                        }
+                }
+                // reassign
+                for (LineSegment ls : otherLineSegments) {
+                        Node n = nodeMap.get(ls.start);
+                        if (n != null)
+                                ls.start = n;
+                        n = nodeMap.get(ls.end);
+                        if (n != null)
+                                ls.end = n;
+                }
+
+
+                // merge line segments
+
+                Map<LineSegment, LineSegment> lsMap = new HashMap<LineSegment, LineSegment>();
+                // find mergable
+                for (LineSegment otherLS : otherLineSegments)
+                        for (LineSegment myLS : myLineSegments)
+                                if (otherLS.start == myLS.start && otherLS.end == myLS.end)
+                                        lsMap.put(otherLS, myLS);
+                // add pendings (ls from track are added later
+                for (LineSegment ls : ds.pendingLineSegments) {
+                        if (!lsMap.containsKey(ls)) {
+                                pendingLineSegments.add(ls);
+                                data.add(ls);
+                        }
+                }
+                // reassign
+                for (Track t : ds.tracks) {
+                        for (int i = 0; i < t.segments.size(); ++i) {
+                                LineSegment newLS = lsMap.get(t.segments.get(i));
+                                if (newLS != null)
+                                        t.segments.set(i, newLS);
+                        }
+                }
+                
+                
+                // merge tracks
+                LinkedList<Track> trackToAdd = new LinkedList<Track>();
+                for (Track otherTrack : ds.tracks) {
+                        boolean found = false;
+                        for (Track myTrack : tracks) {
+                                if (myTrack.segments.equals(otherTrack.segments)) {
+                                        found = true;
+                                        data.add(myTrack);
+                                        break;
                                 }
                         }
-                        nodes.addAll(nodesToAdd);
-                        for (Track t : ds.tracks) {
-                                for (LineSegment ls : t.segments()) {
-                                        Node n = mergeMap.get(ls.getStart());
-                                        if (n != null)
-                                                ls.start = n;
-                                        n = mergeMap.get(ls.getEnd());
-                                        if (n != null)
-                                                ls.end = n;
-                                }
-                        }
-                        tracks.addAll(ds.tracks);
-                        for (LineSegment ls : ds.pendingLineSegments) {
-                                Node n = mergeMap.get(ls.getStart());
-                                if (n != null)
-                                        ls.start = n;
-                                n = mergeMap.get(ls.getEnd());
-                                if (n != null)
-                                        ls.end = n;
-                        }
-                        pendingLineSegments.addAll(ds.pendingLineSegments);
-                } else {
-                        nodes.addAll(ds.nodes);
-                        tracks.addAll(ds.tracks);
-                        pendingLineSegments.addAll(ds.pendingLineSegments);
-                }
+                        if (!found)
+                                trackToAdd.add(otherTrack);
+                }
+                data.addAll(trackToAdd);
+                tracks.addAll(trackToAdd);
+
+                rebuildBackReferences();
+                return data;
         }