Changeset 7 in josm for src/org/openstreetmap/josm/data


Ignore:
Timestamp:
2005-10-02T20:32:00+02:00 (15 years ago)
Author:
imi
Message:

added mapmodes for adding and combining stuff. Reorganized images

Location:
src/org/openstreetmap/josm/data
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • src/org/openstreetmap/josm/data/GeoPoint.java

    r6 r7  
    11package org.openstreetmap.josm.data;
     2
    23
    34
     
    6566                return super.hashCode();
    6667        }
     68
     69        /**
     70         * Return the squared distance of the northing/easting values between
     71         * this and the argument.
     72         *
     73         * @param other The other point to calculate the distance to.
     74         * @return The square of the distance between this and the other point,
     75         *              regarding to the x/y values.
     76         */
     77        public double distanceXY(GeoPoint other) {
     78                return (x-other.x)*(x-other.x)+(y-other.y)*(y-other.y);
     79        }
    6780       
    6881       
  • src/org/openstreetmap/josm/data/osm/DataSet.java

    r6 r7  
    22
    33import java.util.Collection;
    4 import java.util.List;
     4import java.util.HashSet;
     5import java.util.LinkedList;
    56
    67import org.openstreetmap.josm.data.Bounds;
     
    1920
    2021        /**
    21          * All nodes goes here, even when included in other data (tracks etc) listed.
     22         * All nodes goes here, even when included in other data (tracks etc).
    2223         * This enables the instant conversion of the whole DataSet by iterating over
    2324         * this data structure.
    2425         */
    25         public List<Node> allNodes;
     26        public Collection<Node> nodes = new LinkedList<Node>();
     27
     28        /**
     29         * All pending line segments goes here. Pending line segments are those, that
     30         * are in this list but are in no track.
     31         */
     32        public Collection<LineSegment> pendingLineSegments = new LinkedList<LineSegment>();
    2633
    2734        /**
     
    3239         * track list.
    3340         */
    34         public List<Track> tracks;
     41        public Collection<Track> tracks;
    3542
    3643        /**
     
    4451         */
    4552        public Bounds getBoundsXY() {
    46                 if (allNodes.size() == 0)
     53                if (nodes.isEmpty())
    4754                        return null;
    4855
    49                 Bounds b = new Bounds(allNodes.get(0).coor.clone(), allNodes.get(0).coor.clone());
    50                 for (Node w : allNodes)
     56                Node first = nodes.iterator().next();
     57                Bounds b = new Bounds(first.coor.clone(), first.coor.clone());
     58                for (Node w : nodes)
    5159                {
    5260                        if (Double.isNaN(w.coor.x) || Double.isNaN(w.coor.y))
     
    6573
    6674        /**
     75         * Return all tracks that contain the node. If nothing found, an empty array
     76         * is returned.
     77         *
     78         * @param node This node is searched.
     79         * @return All tracks, that reference the node in one of its line segments.
     80         */
     81        public Collection<Track> getReferencedTracks(Node n) {
     82                Collection<Track> all = new LinkedList<Track>();
     83                for (Track t : tracks) {
     84                        for (LineSegment ls : t.segments) {
     85                                if (ls.start == n || ls.end == n) {
     86                                        all.add(t);
     87                                        break;
     88                                }
     89                        }
     90                }
     91                return all;
     92        }
     93       
     94        /**
    6795         * Return the bounds of this DataSet, depending on lat/lon values.
    6896         * The min of the return value is the upper left GeoPoint, the max the lower
     
    75103         */
    76104        public Bounds getBoundsLatLon() {
    77                 if (allNodes.size() == 0)
     105                if (nodes.isEmpty())
    78106                        return null;
    79107
    80                 Bounds b = new Bounds(allNodes.get(0).coor.clone(), allNodes.get(0).coor.clone());
    81                 for (Node w : allNodes)
     108                Node first = nodes.iterator().next();
     109                Bounds b = new Bounds(first.coor.clone(), first.coor.clone());
     110                for (Node w : nodes)
    82111                {
    83112                        if (Double.isNaN(w.coor.lat) || Double.isNaN(w.coor.lon))
     
    99128         */
    100129        public void clearSelection() {
    101                 clearSelection(allNodes);
     130                clearSelection(nodes);
    102131                clearSelection(tracks);
    103132                for (Track t : tracks)
    104133                        clearSelection(t.segments);
     134        }
     135
     136        /**
     137         * Return a list of all selected objects. Even keys are returned.
     138         * @return List of all selected objects.
     139         */
     140        public Collection<OsmPrimitive> getSelected() {
     141                Collection<OsmPrimitive> sel = getSelected(nodes);
     142                sel.addAll(getSelected(pendingLineSegments));
     143                sel.addAll(getSelected(tracks));
     144                for (Track t : tracks)
     145                        sel.addAll(getSelected(t.segments));
     146                return sel;
    105147        }
    106148       
     
    118160                }
    119161        }
    120        
     162
     163        /**
     164         * Return all selected items in the collection.
     165         * @param list The collection from which the selected items are returned.
     166         */
     167        private Collection<OsmPrimitive> getSelected(Collection<? extends OsmPrimitive> list) {
     168                Collection<OsmPrimitive> sel = new HashSet<OsmPrimitive>();
     169                if (list == null)
     170                        return sel;
     171                for (OsmPrimitive osm : list) {
     172                        if (osm.selected)
     173                                sel.add(osm);
     174                        if (osm.keys != null)
     175                                sel.addAll(getSelected(osm.keys.keySet()));
     176                }
     177                return sel;
     178        }
     179
     180
    121181        @Override
    122182        public DataSet clone() {
  • src/org/openstreetmap/josm/data/osm/Key.java

    r1 r7  
    11package org.openstreetmap.josm.data.osm;
     2
     3import java.util.Collection;
     4import java.util.LinkedList;
    25
    36
     
    1316         */
    1417        public String name;
     18
     19        /**
     20         * Return an empty list, since keys cannot have nodes.
     21         */
     22        @Override
     23        public Collection<Node> getAllNodes() {
     24                return new LinkedList<Node>();
     25        }
     26
     27        /**
     28         * Keys are equal, when their name is equal, regardless of their other keys.
     29         */
     30        @Override
     31        public boolean equals(Object obj) {
     32                if (!(obj instanceof Key))
     33                        return false;
     34                return name.equals(((Key)obj).name);
     35        }
     36
     37        @Override
     38        public int hashCode() {
     39                return name.hashCode();
     40        }
    1541}
  • src/org/openstreetmap/josm/data/osm/LineSegment.java

    r1 r7  
    11package org.openstreetmap.josm.data.osm;
     2
     3import java.util.Collection;
     4import java.util.LinkedList;
    25
    36
     
    2831         */
    2932        public Node end;
     33
     34        /**
     35         * Return start and end in a list.
     36         */
     37        @Override
     38        public Collection<Node> getAllNodes() {
     39                LinkedList<Node> nodes = new LinkedList<Node>();
     40                nodes.add(start);
     41                nodes.add(end);
     42                return nodes;
     43        }
     44
     45        /**
     46         * Line segments are equal, if their starting and ending node and their
     47         * keys are equal.
     48         */
     49        @Override
     50        public boolean equals(Object obj) {
     51                if (!(obj instanceof LineSegment))
     52                        return false;
     53                return super.equals(obj) &&
     54                        start.equals(((LineSegment)obj).start) &&
     55                        end.equals(((LineSegment)obj).end);
     56        }
     57
     58        @Override
     59        public int hashCode() {
     60                return super.hashCode() + start.hashCode() + end.hashCode();
     61        }
    3062}       
  • src/org/openstreetmap/josm/data/osm/Node.java

    r6 r7  
    11package org.openstreetmap.josm.data.osm;
     2
     3import java.util.Collection;
     4import java.util.LinkedList;
    25
    36import org.openstreetmap.josm.data.GeoPoint;
     
    3639                return (coor == null ? 0 : coor.hashCode()) + super.hashCode();
    3740        }
     41
     42        /**
     43         * Return a list only this added.
     44         */
     45        @Override
     46        public Collection<Node> getAllNodes() {
     47                LinkedList<Node> nodes = new LinkedList<Node>();
     48                nodes.add(this);
     49                return nodes;
     50        }
    3851       
    3952       
  • src/org/openstreetmap/josm/data/osm/OsmPrimitive.java

    r6 r7  
    11package org.openstreetmap.josm.data.osm;
    22
     3import java.util.Collection;
    34import java.util.Map;
    45
     
    1011 * @author imi
    1112 */
    12 public class OsmPrimitive {
     13abstract public class OsmPrimitive {
    1314
    1415        /**
     
    2728        transient public boolean selected = false;
    2829
     30        /**
     31         * Return a list of all nodes, this osmPrimitive consists of. Does return
     32         * an empty list, if it is an primitive that cannot have nodes (e.g. Key)
     33         */
     34        abstract public Collection<Node> getAllNodes();
     35
     36        /**
     37         * Return <code>true</code>, if either <code>this.keys</code> and
     38         * <code>other.keys</code> is <code>null</code> or if they do not share Keys
     39         * with different values.
     40         * 
     41         * @param other         The second key-set to compare with.
     42         * @return      True, if the keysets are mergable
     43         */
     44        public boolean keyPropertiesMergable(OsmPrimitive other) {
     45                if ((keys == null) != (other.keys == null))
     46                        return false;
     47
     48                if (keys != null) {
     49                        for (Key k : keys.keySet())
     50                                if (other.keys.containsKey(k) && !keys.get(k).equals(other.keys.get(k)))
     51                                        return false;
     52                        for (Key k : other.keys.keySet())
     53                                if (keys.containsKey(k) && !other.keys.get(k).equals(keys.get(k)))
     54                                        return false;
     55                }
     56                return true;
     57        }
     58       
    2959        /**
    3060         * Osm primitives are equal, when their keys are equal.
     
    4979                return keys == null ? 0 : keys.hashCode();
    5080        }
    51        
    52        
    5381}
  • src/org/openstreetmap/josm/data/osm/Track.java

    r1 r7  
    22
    33import java.util.ArrayList;
     4import java.util.Collection;
    45import java.util.List;
    56
     
    1415         * All track segments in this track
    1516         */
    16         public List<LineSegment> segments = new ArrayList<LineSegment>();
     17        public final List<LineSegment> segments = new ArrayList<LineSegment>();
     18
     19        /**
     20         * Return a merge of getAllNodes - calls to the line segments.
     21         */
     22        @Override
     23        public Collection<Node> getAllNodes() {
     24                ArrayList<Node> nodes = new ArrayList<Node>();
     25                for (LineSegment ls : segments)
     26                        nodes.addAll(ls.getAllNodes());
     27                return nodes;
     28        }
     29
     30        /**
     31         * Tracks are equal, when all segments and the keys are equal
     32         */
     33        @Override
     34        public boolean equals(Object obj) {
     35                if (!(obj instanceof Track))
     36                        return false;
     37                if (!super.equals(obj))
     38                        return false;
     39                Track t = (Track)obj;
     40                int size = segments.size();
     41                if (size != t.segments.size())
     42                        return false;
     43                for (int i = 0; i < size; ++i)
     44                        if (!segments.get(i).equals(t.segments.get(i)))
     45                                return false;
     46                return true;
     47        }
     48
     49        @Override
     50        public int hashCode() {
     51                int hash = super.hashCode();
     52                for (LineSegment ls : segments)
     53                        hash += ls.hashCode();
     54                return hash;
     55        }
     56
     57        /**
     58         * Return the last node in the track. This is the node, which no line segment
     59         * has as start, but at least one has it as end. If there are not exact one
     60         * such nodes found, <code>null</code> is returned.
     61         *
     62         * TODO Currently does return just the end node in the list.
     63         *
     64         * @return The ending node, if there is one.
     65         */
     66        public Node getEndingNode() {
     67                if (segments.isEmpty())
     68                        return null;
     69                return segments.get(segments.size()-1).end;
     70        }
     71
     72        /**
     73         * Return the first node in the track. This is the node, which no line segment
     74         * has as end, but at least one as starting node. If there are not exact one
     75         * such nodes found, <code>null</code> is returned.
     76         *
     77         * TODO Currently does return just the first node in the list.
     78         *
     79         * @return The starting node, if there is one.
     80         */
     81        public Node getStartingNode() {
     82                if (segments.isEmpty())
     83                        return null;
     84                return segments.get(0).start;
     85        }
    1786}
  • src/org/openstreetmap/josm/data/projection/Projection.java

    r6 r7  
    8989         */
    9090        public void init(DataSet dataSet) {
    91                 for (Node w : dataSet.allNodes)
     91                for (Node w : dataSet.nodes)
    9292                        latlon2xy(w.coor);
    9393        }
Note: See TracChangeset for help on using the changeset viewer.