Ticket #13415: patch-latlon-generic.patch

src/org/openstreetmap/josm/actions/AddNodeAction.java

@@ -66 +66 @@
         Main.main.undoRedo.add(new AddCommand(nnew));
         getLayerManager().getEditDataSet().setSelected(nnew);
         if (Main.map.mapView != null) {
-            if (Main.map.mapView.getRealBounds().contains(nnew.getCoor())) {
+            if (Main.map.mapView.getRealBounds().contains(nnew)) {
                 Main.map.mapView.repaint();
             } else {
                 AutoScaleAction.zoomTo(Collections.<OsmPrimitive>singleton(nnew));

src/org/openstreetmap/josm/actions/CopyCoordinatesAction.java

@@ -30 +30 @@
     public void actionPerformed(ActionEvent ae) {
         StringBuilder s = new StringBuilder();
         for (Node n : getSelectedNodes()) {
-            s.append(n.getCoor().lat());
+            s.append(n.lat());
             s.append(", ");
-            s.append(n.getCoor().lon());
+            s.append(n.lon());
             s.append('\n');
         }
         ClipboardUtils.copyString(s.toString().trim());

src/org/openstreetmap/josm/actions/SimplifyWayAction.java

@@ -227 +227 @@
         for (int i = from + 1; i < to; i++) {
             Node n = wnew.get(i);
             double xte = Math.abs(Ellipsoid.WGS84.a
-                    * xtd(fromN.getCoor().lat() * Math.PI / 180, fromN.getCoor().lon() * Math.PI / 180, toN.getCoor().lat() * Math.PI
-                            / 180, toN.getCoor().lon() * Math.PI / 180, n.getCoor().lat() * Math.PI / 180, n.getCoor().lon() * Math.PI
-                            / 180));
+                    * xtd(fromN.lat() * Math.PI / 180, fromN.lon() * Math.PI / 180, toN.lat() * Math.PI / 180,
+                            toN.lon() * Math.PI / 180,     n.lat() * Math.PI / 180,   n.lon() * Math.PI / 180));
             if (xte > xtemax) {
                 xtemax = xte;
                 imax = i;

src/org/openstreetmap/josm/actions/mapmode/ExtrudeAction.java

@@ -1062 +1062 @@
                     }
                 } else if (mode == Mode.translate || mode == Mode.translate_node) {
                     g2.setColor(mainColor);
-                    if (p1.distance(p2) < 3) {
+                    MapViewPath line = new MapViewPath(mv.getState()).moveTo(p1).lineTo(p2);
+                    if (line.getBounds2D().getWidth() < 3 && line.getBounds2D().getHeight() < 3) {
                         g2.setStroke(mainStroke);
-                        g2.draw(new MapViewPath(mv.getState()).shapeAround(p1, SymbolShape.CIRCLE, symbolSize));
+                        g2.draw(new MapViewPath(mv.getState()).shapeAround(p1.interpolate(p2, .5), SymbolShape.CIRCLE, symbolSize));
                     } else {
                         g2.setStroke(oldLineStroke);
-                        g2.draw(new MapViewPath(mv.getState()).moveTo(p1).lineTo(p2));
+                        g2.draw(line);
                     }
 
                     if (dualAlignActive) {

src/org/openstreetmap/josm/data/Bounds.java

@@ -9 +9 @@
 import java.util.Objects;
 import java.util.function.Consumer;
 
+import org.openstreetmap.josm.data.coor.ILatLon;
 import org.openstreetmap.josm.data.coor.LatLon;
 import org.openstreetmap.josm.data.osm.BBox;
 import org.openstreetmap.josm.data.projection.Projection;
@@ -345 +346 @@
 
     /**
      * Determines if the given point {@code ll} is within these bounds.
+     * <p>
+     * Points with unknown coordinates are always outside the coordinates.
      * @param ll The lat/lon to check
      * @return {@code true} if {@code ll} is within these bounds, {@code false} otherwise
      */
     public boolean contains(LatLon ll) {
+        // binary compatibility
+        return contains((ILatLon) ll);
+    }
+
+    /**
+     * Determines if the given point {@code ll} is within these bounds.
+     * <p>
+     * Points with unknown coordinates are always outside the coordinates.
+     * @param ll The lat/lon to check
+     * @return {@code true} if {@code ll} is within these bounds, {@code false} otherwise
+     */
+    public boolean contains(ILatLon ll) {
+        if (!ll.isLatLonKnown()) {
+            return false;
+        }
         if (ll.lat() < minLat || ll.lat() > maxLat)
             return false;
         if (crosses180thMeridian()) {

src/org/openstreetmap/josm/data/coor/CachedLatLon.java

@@ -4 +4 @@
 import java.util.Objects;
 
 import org.openstreetmap.josm.Main;
-import org.openstreetmap.josm.data.projection.Projection;
+import org.openstreetmap.josm.data.projection.Projecting;
 
 /**
  * LatLon class that maintains a cache of projected EastNorth coordinates.
@@ -19 +19 @@
     private static final long serialVersionUID = 1L;
 
     private EastNorth eastNorth;
-    private transient Projection proj;
+    private transient Object proj;
 
     /**
      * Constructs a new {@code CachedLatLon}.
@@ -45 +45 @@
      */
     public CachedLatLon(EastNorth eastNorth) {
         super(Main.getProjection().eastNorth2latlon(eastNorth));
-        proj = Main.getProjection();
+        proj = Main.getProjection().getCacheKey();
         this.eastNorth = eastNorth;
     }
 
@@ -54 +54 @@
      *
      * @return the internally cached east/north coordinates. null, if the globally defined projection is null
      */
-    public final EastNorth getEastNorth() {
-        if (!Objects.equals(proj, Main.getProjection())) {
-            proj = Main.getProjection();
-            eastNorth = proj.latlon2eastNorth(this);
+    @Override
+    public final EastNorth getEastNorth(Projecting projecting) {
+        if (!Objects.equals(proj, projecting.getCacheKey())) {
+            proj = projecting.getCacheKey();
+            eastNorth = projecting.latlon2eastNorth(this);
         }
         return eastNorth;
     }

new file src/org/openstreetmap/josm/data/coor/ILatLon.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.coor;
+
+import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.data.projection.Projecting;
+
+/**
+ * This interface represents a coordinate in LatLon space.
+ * <p>
+ * It provides methods to get the coordinates. The coordinates may be unknown.
+ * In this case, both {@link #lat()} and {@link #lon()} need to return a NaN value and {@link #isLatLonKnown()} needs to return false.
+ * <p>
+ * Whether the coordinates are immutable or not is implementation specific.
+ *
+ * @author Michael Zangl
+ * @since xxx
+ */
+public interface ILatLon {
+
+    /**
+     * Returns the longitude, i.e., the east-west position in degrees.
+     * @return the longitude or NaN if {@link #isLatLonKnown()} returns false
+     */
+    public double lon();
+
+    /**
+     * Returns the latitude, i.e., the north-south position in degrees.
+     * @return the latitude or NaN if {@link #isLatLonKnown()} returns false
+     */
+    public double lat();
+
+    /**
+     * Determines if this object has valid coordinates.
+     * @return {@code true} if this object has valid coordinates
+     */
+    default boolean isLatLonKnown() {
+        return !Double.isNaN(lat()) && !Double.isNaN(lon());
+    }
+
+    /**
+     * <p>Replies the projected east/north coordinates.</p>
+     *
+     * <p>Uses the {@link Main#getProjection() global projection} to project the lan/lon-coordinates.</p>
+     *
+     * @return the east north coordinates or {@code null} if #is
+     */
+    default EastNorth getEastNorth() {
+        return getEastNorth(Main.getProjection());
+    }
+
+    /**
+     * Replies the projected east/north coordinates.
+     * <p>
+     * The result of the last conversion is cached. The cache object is used as cache key.
+     * @param projecting The projection to use.
+     * @return The projected east/north coordinates
+     * @since 10827
+     */
+    default EastNorth getEastNorth(Projecting projecting) {
+        return projecting.latlon2eastNorth(this);
+    }
+}

src/org/openstreetmap/josm/data/coor/LatLon.java

@@ -38 +38 @@
  *
  * @author Imi
  */
-public class LatLon extends Coordinate {
+public class LatLon extends Coordinate implements ILatLon {
 
     private static final long serialVersionUID = 1L;
 
@@ -213 +213 @@
         super(lon, lat);
     }
 
-    protected LatLon(LatLon coor) {
+    /**
+     * Creates a new LatLon object for the given coordinate
+     * @param coor The coordinates to copy from.
+     */
+    public LatLon(ILatLon coor) {
         super(coor.lon(), coor.lat());
     }
 
@@ -225 +229 @@
         this(coor.getLat(), coor.getLon());
     }
 
-    /**
-     * Returns the latitude, i.e., the north-south position in degrees.
-     * @return the latitude
-     */
+    @Override
     public double lat() {
         return y;
     }
@@ -251 +252 @@
         }
     }
 
-    /**
-     * Returns the longitude, i.e., the east-west position in degrees.
-     * @return the longitude
-     */
+    @Override
     public double lon() {
         return x;
     }

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

@@ -5 +5 @@
 import java.util.Arrays;
 import java.util.Objects;
 
+import org.openstreetmap.josm.data.coor.ILatLon;
 import org.openstreetmap.josm.data.coor.LatLon;
 import org.openstreetmap.josm.data.coor.QuadTiling;
 import org.openstreetmap.josm.tools.Utils;
@@ -75 +76 @@
 
     public BBox(Way w) {
         for (Node n : w.getNodes()) {
-            LatLon coor = n.getCoor();
-            if (coor == null) {
-                continue;
-            }
-            add(coor);
+            add(n);
         }
     }
 
-    public BBox(Node n) {
-        LatLon coor = n.getCoor();
-        if (coor == null) {
+    public BBox(ILatLon n) {
+        if (!n.isLatLonKnown()) {
             xmin = xmax = ymin = ymax = 0;
         } else {
-            xmin = xmax = coor.lon();
-            ymin = ymax = coor.lat();
+            xmin = xmax = n.lon();
+            ymin = ymax = n.lat();
         }
     }
 
+    public BBox(Node n) {
+        this((ILatLon) n);
+    }
+
     private void sanity() {
         if (xmin < -180.0) {
             xmin = -180.0;
@@ -112 +112 @@
         add(c.lon(), c.lat());
     }
 
+    public final void add(ILatLon c) {
+        if (c.isLatLonKnown()) {
+            add(c.lon(), c.lat());
+        }
+    }
+
     /**
      * Extends this bbox to include the point (x, y)
      * @param x X coordinate

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

@@ -2 +2 @@
 package org.openstreetmap.josm.data.osm;
 
 import org.openstreetmap.josm.data.coor.EastNorth;
+import org.openstreetmap.josm.data.coor.ILatLon;
 import org.openstreetmap.josm.data.coor.LatLon;
 
 /**
  * INode captures the common functions of {@link Node} and {@link NodeData}.
  * @since 4098
  */
-public interface INode extends IPrimitive {
+public interface INode extends IPrimitive, ILatLon {
 
     /**
      * Returns lat/lon coordinates of this node.
@@ -23 +24 @@
     void setCoor(LatLon coor);
 
     /**
-     * Returns east/north coordinates of this node.
-     * @return east/north coordinates of this node
-     */
-    EastNorth getEastNorth();
-
-    /**
      * Sets east/north coordinates of this node.
      * @param eastNorth east/north coordinates of this node
      */

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

@@ -12 +12 @@
 import org.openstreetmap.josm.data.coor.LatLon;
 import org.openstreetmap.josm.data.osm.visitor.PrimitiveVisitor;
 import org.openstreetmap.josm.data.osm.visitor.Visitor;
-import org.openstreetmap.josm.data.projection.Projection;
+import org.openstreetmap.josm.data.projection.Projecting;
 import org.openstreetmap.josm.data.projection.Projections;
 import org.openstreetmap.josm.tools.CheckParameterUtil;
 import org.openstreetmap.josm.tools.Utils;
@@ -45 +45 @@
      * @return {@code true} if this node has valid coordinates
      * @since 7828
      */
+    @Override
     public boolean isLatLonKnown() {
+        // We cannot use default implementation - if we remove this implementation, we will break binary compatibility.
         return !Double.isNaN(lat) && !Double.isNaN(lon);
     }
 
@@ -74 +76 @@
 
     @Override
     public LatLon getCoor() {
-        if (!isLatLonKnown()) return null;
-        return new LatLon(lat, lon);
+        if (!isLatLonKnown()) {
+            return null;
+        } else {
+            return new LatLon(lat, lon);
+        }
     }
 
-    /**
-     * <p>Replies the projected east/north coordinates.</p>
-     *
-     * <p>Uses the {@link Main#getProjection() global projection} to project the lan/lon-coordinates.
-     * Internally caches the projected coordinates.</p>
-     *
-     * <p>Replies {@code null} if this node doesn't know lat/lon-coordinates, i.e. because it is an incomplete node.
-     *
-     * @return the east north coordinates or {@code null}
-     * @see #invalidateEastNorthCache()
-     *
-     */
     @Override
-    public EastNorth getEastNorth() {
-        return getEastNorth(Main.getProjection());
+    public double lat() {
+        return lat;
     }
 
-    /**
-     * Replies the projected east/north coordinates.
-     * <p>
-     * The result of the last conversion is cached. The cache object is used as cache key.
-     * @param projection The projection to use.
-     * @return The projected east/north coordinates
-     * @since 10827
-     */
-    public EastNorth getEastNorth(Projection projection) {
+    @Override
+    public double lon() {
+        return lon;
+    }
+
+    @Override
+    public EastNorth getEastNorth(Projecting projection) {
         if (!isLatLonKnown()) return null;
 
         if (Double.isNaN(east) || Double.isNaN(north) || !Objects.equals(projection.getCacheKey(), eastNorthCacheKey)) {

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

@@ -31 +31 @@
         setCoor(data.getCoor());
     }
 
-    private boolean isLatLonKnown() {
+    @Override
+    public double lat() {
+        return lat;
+    }
+
+    @Override
+    public double lon() {
+        return lon;
+    }
+
+    @Override
+    public boolean isLatLonKnown() {
         return !Double.isNaN(lat) && !Double.isNaN(lon);
     }
 

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

@@ -19 +19 @@
         if (n1.getCoor().equalsEpsilon(n2.getCoor()))
             return 0;
 
-        int dLat = Double.compare(n1.getCoor().lat(), n2.getCoor().lat());
-        return dLat != 0 ? dLat : Double.compare(n1.getCoor().lon(), n2.getCoor().lon());
+        int dLat = Double.compare(n1.lat(), n2.lat());
+        return dLat != 0 ? dLat : Double.compare(n1.lon(), n2.lon());
     }
 }

src/org/openstreetmap/josm/data/projection/AbstractProjection.java

@@ -9 +9 @@
 import org.openstreetmap.josm.data.Bounds;
 import org.openstreetmap.josm.data.ProjectionBounds;
 import org.openstreetmap.josm.data.coor.EastNorth;
+import org.openstreetmap.josm.data.coor.ILatLon;
 import org.openstreetmap.josm.data.coor.LatLon;
 import org.openstreetmap.josm.data.projection.datum.Datum;
 import org.openstreetmap.josm.data.projection.proj.Proj;
@@ -113 +114 @@
     }
 
     @Override
-    public EastNorth latlon2eastNorth(LatLon ll) {
+    public EastNorth latlon2eastNorth(ILatLon ll) {
         ll = datum.fromWGS84(ll);
         double[] en = proj.project(Math.toRadians(ll.lat()), Math.toRadians(LatLon.normalizeLon(ll.lon() - lon0 - pm)));
         return new EastNorth((ellps.a * k0 * en[0] + x0) / toMeter, (ellps.a * k0 * en[1] + y0) / toMeter);
@@ -121 +122 @@
 
     @Override
     public LatLon eastNorth2latlon(EastNorth en) {
+        // We know it is a latlon. Nice would be to change this method return type to ILatLon
         return eastNorth2latlon(en, LatLon::normalizeLon);
     }
 
     @Override
     public LatLon eastNorth2latlonClamped(EastNorth en) {
-        LatLon ll = eastNorth2latlon(en, lon -> Utils.clamp(lon, -180, 180));
+        ILatLon ll = eastNorth2latlon(en, lon -> Utils.clamp(lon, -180, 180));
         Bounds bounds = getWorldBoundsLatLon();
         return new LatLon(Utils.clamp(ll.lat(), bounds.getMinLat(), bounds.getMaxLat()),
                 Utils.clamp(ll.lon(), bounds.getMinLon(), bounds.getMaxLon()));

src/org/openstreetmap/josm/data/projection/Ellipsoid.java

@@ -6 +6 @@
  */
 package org.openstreetmap.josm.data.projection;
 
+import org.openstreetmap.josm.data.coor.ILatLon;
 import org.openstreetmap.josm.data.coor.LatLon;
 
 /**
@@ -347 +348 @@
      * @param coord The Latitude and longitude in degrees
      * @return the corresponding (X, Y Z) cartesian coordinates in meters.
      */
-    public double[] latLon2Cart(LatLon coord) {
+    public double[] latLon2Cart(ILatLon coord) {
         double phi = Math.toRadians(coord.lat());
         double lambda = Math.toRadians(coord.lon());
 

src/org/openstreetmap/josm/data/projection/Projecting.java

@@ -5 +5 @@
 
 import org.openstreetmap.josm.data.ProjectionBounds;
 import org.openstreetmap.josm.data.coor.EastNorth;
+import org.openstreetmap.josm.data.coor.ILatLon;
 import org.openstreetmap.josm.data.coor.LatLon;
 
 /**
@@ -18 +19 @@
 
     /**
      * Convert from lat/lon to easting/northing.
+     * <p>
+     * This method exists to not break binary compatibility with old plugins
      *
      * @param ll the geographical point to convert (in WGS84 lat/lon)
      * @return the corresponding east/north coordinates
      */
-    EastNorth latlon2eastNorth(LatLon ll);
+    default EastNorth latlon2eastNorth(LatLon ll) {
+        return latlon2eastNorth((ILatLon) ll);
+    }
+
+    /**
+     * Convert from lat/lon to easting/northing. This method uses the newer {@link ILatLon} interface.
+     *
+     * @param ll the geographical point to convert (in WGS84 lat/lon)
+     * @return the corresponding east/north coordinates
+     */
+    EastNorth latlon2eastNorth(ILatLon ll);
 
     /**
      * Convert a east/north coordinate to the {@link LatLon} coordinate.
@@ -47 +60 @@
      * @return a map of non-overlapping {@link ProjectionBounds} instances mapped to the {@link Projecting} object to use for that area.
      */
     Map<ProjectionBounds, Projecting> getProjectingsForArea(ProjectionBounds area);
+
+    /**
+     * Gets the object used as cache identifier when caching results of this projection.
+     * @return The object to use as cache key
+     * @since 10827
+     */
+    default Object getCacheKey() {
+        return this;
+    }
 }

src/org/openstreetmap/josm/data/projection/Projection.java

@@ -102 +102 @@
      * @return true if natural order of coordinates is North East, false if East North
      */
     boolean switchXY();
-
-    /**
-     * Gets the object used as cache identifier when caching results of this projection.
-     * @return The object to use as cache key
-     * @since 10827
-     */
-    default Object getCacheKey() {
-        return this;
-    }
 }

src/org/openstreetmap/josm/data/projection/ShiftedProjecting.java

@@ -6 +6 @@
 
 import org.openstreetmap.josm.data.ProjectionBounds;
 import org.openstreetmap.josm.data.coor.EastNorth;
+import org.openstreetmap.josm.data.coor.ILatLon;
 import org.openstreetmap.josm.data.coor.LatLon;
 
 /**
@@ -28 +29 @@
     }
 
     @Override
-    public EastNorth latlon2eastNorth(LatLon ll) {
+    public EastNorth latlon2eastNorth(ILatLon ll) {
         return base.latlon2eastNorth(ll).add(offset);
     }
 

src/org/openstreetmap/josm/data/projection/datum/CentricDatum.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.data.projection.datum;
 
+import org.openstreetmap.josm.data.coor.ILatLon;
 import org.openstreetmap.josm.data.coor.LatLon;
 import org.openstreetmap.josm.data.projection.Ellipsoid;
 
@@ -15 +16 @@
     }
 
     @Override
-    public LatLon toWGS84(LatLon ll) {
+    public LatLon toWGS84(ILatLon ll) {
         return Ellipsoid.WGS84.cart2LatLon(ellps.latLon2Cart(ll));
     }
 
     @Override
-    public LatLon fromWGS84(LatLon ll) {
+    public ILatLon fromWGS84(ILatLon ll) {
         return this.ellps.cart2LatLon(Ellipsoid.WGS84.latLon2Cart(ll));
     }
 

src/org/openstreetmap/josm/data/projection/datum/Datum.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.data.projection.datum;
 
+import org.openstreetmap.josm.data.coor.ILatLon;
 import org.openstreetmap.josm.data.coor.LatLon;
 import org.openstreetmap.josm.data.projection.Ellipsoid;
 
@@ -33 +34 @@
      * @param ll original lat/lon in this datum
      * @return lat/lon converted to WGS84
      */
-    LatLon toWGS84(LatLon ll);
+    LatLon toWGS84(ILatLon ll);
 
     /**
      * Convert lat/lon from {@link Ellipsoid#WGS84} to this datum.
      * @param ll original lat/lon in WGS84
      * @return converted lat/lon in this datum
      */
-    LatLon fromWGS84(LatLon ll);
+    ILatLon fromWGS84(ILatLon ll);
 }

src/org/openstreetmap/josm/data/projection/datum/NTV2Datum.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.data.projection.datum;
 
+import org.openstreetmap.josm.data.coor.ILatLon;
 import org.openstreetmap.josm.data.coor.LatLon;
 import org.openstreetmap.josm.data.projection.Ellipsoid;
 
@@ -17 +18 @@
     }
 
     @Override
-    public LatLon toWGS84(LatLon ll) {
+    public LatLon toWGS84(ILatLon ll) {
         NTV2GridShift gs = new NTV2GridShift(ll);
         nadgrids.getShiftFile().gridShiftForward(gs);
         return new LatLon(ll.lat() + gs.getLatShiftDegrees(), ll.lon() + gs.getLonShiftPositiveEastDegrees());
     }
 
     @Override
-    public LatLon fromWGS84(LatLon ll) {
+    public ILatLon fromWGS84(ILatLon ll) {
         NTV2GridShift gs = new NTV2GridShift(ll);
         nadgrids.getShiftFile().gridShiftReverse(gs);
         return new LatLon(ll.lat() + gs.getLatShiftDegrees(), ll.lon() + gs.getLonShiftPositiveEastDegrees());

src/org/openstreetmap/josm/data/projection/datum/NTV2GridShift.java

@@ -21 +21 @@
 
 import java.io.Serializable;
 
-import org.openstreetmap.josm.data.coor.LatLon;
+import org.openstreetmap.josm.data.coor.ILatLon;
 import org.openstreetmap.josm.data.projection.Ellipsoid;
 
 /**
@@ -62 +62 @@
      * Constructs a new {@code NTV2GridShift} from a {@code LatLon}.
      * @param p lat/lon
      */
-    public NTV2GridShift(LatLon p) {
+    public NTV2GridShift(ILatLon p) {
         setLatDegrees(p.lat());
         setLonPositiveEastDegrees(p.lon());
     }

src/org/openstreetmap/josm/data/projection/datum/NullDatum.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.data.projection.datum;
 
+import org.openstreetmap.josm.data.coor.ILatLon;
 import org.openstreetmap.josm.data.coor.LatLon;
 import org.openstreetmap.josm.data.projection.Ellipsoid;
 
@@ -15 +16 @@
     }
 
     @Override
-    public LatLon toWGS84(LatLon ll) {
-        return ll;
+    public LatLon toWGS84(ILatLon ll) {
+        return new LatLon(ll);
     }
 
     @Override
-    public LatLon fromWGS84(LatLon ll) {
+    public ILatLon fromWGS84(ILatLon ll) {
         return ll;
     }
 

src/org/openstreetmap/josm/data/projection/datum/SevenParameterDatum.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.data.projection.datum;
 
+import org.openstreetmap.josm.data.coor.ILatLon;
 import org.openstreetmap.josm.data.coor.LatLon;
 import org.openstreetmap.josm.data.projection.Ellipsoid;
 
@@ -45 +46 @@
     }
 
     @Override
-    public LatLon toWGS84(LatLon ll) {
+    public LatLon toWGS84(ILatLon ll) {
         double[] xyz = ellps.latLon2Cart(ll);
         double x = dx + xyz[0]*(1+s) + xyz[2]*ry - xyz[1]*rz;
         double y = dy + xyz[1]*(1+s) + xyz[0]*rz - xyz[2]*rx;
@@ -54 +55 @@
     }
 
     @Override
-    public LatLon fromWGS84(LatLon ll) {
+    public ILatLon fromWGS84(ILatLon ll) {
         double[] xyz = Ellipsoid.WGS84.latLon2Cart(ll);
         double x = (1-s)*(-dx + xyz[0] + ((-dz+xyz[2])*(-ry) - (-dy+xyz[1])*(-rz)));
         double y = (1-s)*(-dy + xyz[1] + ((-dx+xyz[0])*(-rz) - (-dz+xyz[2])*(-rx)));

src/org/openstreetmap/josm/data/projection/datum/ThreeParameterDatum.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.data.projection.datum;
 
+import org.openstreetmap.josm.data.coor.ILatLon;
 import org.openstreetmap.josm.data.coor.LatLon;
 import org.openstreetmap.josm.data.projection.Ellipsoid;
 
@@ -19 +20 @@
     }
 
     @Override
-    public LatLon toWGS84(LatLon ll) {
+    public LatLon toWGS84(ILatLon ll) {
         double[] xyz = ellps.latLon2Cart(ll);
         xyz[0] += dx;
         xyz[1] += dy;
@@ -28 +29 @@
     }
 
     @Override
-    public LatLon fromWGS84(LatLon ll) {
+    public ILatLon fromWGS84(ILatLon ll) {
         double[] xyz = Ellipsoid.WGS84.latLon2Cart(ll);
         xyz[0] -= dx;
         xyz[1] -= dy;

src/org/openstreetmap/josm/data/validation/PaintVisitor.java

@@ -2 +2 @@
 package org.openstreetmap.josm.data.validation;
 
 import java.awt.Color;
-import java.awt.Graphics;
+import java.awt.Graphics2D;
 import java.awt.Point;
 import java.util.HashSet;
 import java.util.List;
@@ -17 +17 @@
 import org.openstreetmap.josm.data.osm.WaySegment;
 import org.openstreetmap.josm.data.osm.visitor.AbstractVisitor;
 import org.openstreetmap.josm.gui.MapView;
+import org.openstreetmap.josm.gui.draw.MapViewPath;
+import org.openstreetmap.josm.gui.mappaint.styleelement.Symbol.SymbolShape;
 
 /**
  * Visitor that highlights the primitives affected by an error
@@ -25 +27 @@
  */
 public class PaintVisitor extends AbstractVisitor implements ValidatorVisitor {
     /** The graphics */
-    private final Graphics g;
+    private final Graphics2D g;
     /** The MapView */
     private final MapView mv;
 
@@ -42 +44 @@
      * @param g The graphics
      * @param mv The Mapview
      */
-    public PaintVisitor(Graphics g, MapView mv) {
+    public PaintVisitor(Graphics2D g, MapView mv) {
         this.g = g;
         this.mv = mv;
     }
@@ -119 +121 @@
         PaintedPoint pp = new PaintedPoint(n.getCoor(), color);
 
         if (!paintedPoints.contains(pp)) {
-            Point p = mv.getPoint(n);
+            MapViewPath circle = new MapViewPath(mv.getState()).shapeAround(n, SymbolShape.CIRCLE, 10);
 
             if (selected) {
                 g.setColor(getHighlightColor(color));
-                g.fillOval(p.x - 5, p.y - 5, 10, 10);
+                g.fill(circle);
             }
             g.setColor(color);
-            g.drawOval(p.x - 5, p.y - 5, 10, 10);
+            g.draw(circle);
             paintedPoints.add(pp);
         }
     }

src/org/openstreetmap/josm/gui/MapViewState.java

@@ -17 +17 @@
 import org.openstreetmap.josm.data.Bounds;
 import org.openstreetmap.josm.data.ProjectionBounds;
 import org.openstreetmap.josm.data.coor.EastNorth;
+import org.openstreetmap.josm.data.coor.ILatLon;
 import org.openstreetmap.josm.data.coor.LatLon;
-import org.openstreetmap.josm.data.osm.Node;
 import org.openstreetmap.josm.data.projection.Projecting;
 import org.openstreetmap.josm.data.projection.Projection;
 import org.openstreetmap.josm.gui.download.DownloadDialog;
@@ -174 +174 @@
     }
 
     /**
-     * Gets the {@link MapViewPoint} for the given {@link LatLon} coordinate.
-     * @param latlon the position
-     * @return The point for that position.
-     * @since 10651
-     */
-    public MapViewPoint getPointFor(LatLon latlon) {
-        return getPointFor(getProjection().latlon2eastNorth(latlon));
-    }
-
-    /**
-     * Gets the {@link MapViewPoint} for the given node. This is faster than {@link #getPointFor(LatLon)} because it uses the node east/north
-     * cache.
-     * @param node The node
-     * @return The position of that node.
-     * @since 10827
+     * Gets the {@link MapViewPoint} for the given lat lon coordinates.
+     * @param latlon The lat lon position, e.g. a node
+     * @return The position of that object.
+     * @since xxx
      */
-    public MapViewPoint getPointFor(Node node) {
-        return getPointFor(node.getEastNorth(getProjection()));
+    public MapViewPoint getPointFor(ILatLon latlon) {
+        return getPointFor(latlon.getEastNorth(getProjecting()));
     }
 
     /**
@@ -248 +237 @@
     /**
      * Gets the current projection used for the MapView.
      * @return The projection.
+     * @see #getProjecting()
      */
     public Projection getProjection() {
         return projecting.getBaseProjection();
     }
 
     /**
+     * Gets the current projecting instance that is used to convert between east/north and lat/lon space.
+     * @return The projection.
+     * @since xxx
+     */
+    public Projecting getProjecting() {
+        return projecting;
+    }
+
+    /**
      * Creates an affine transform that is used to convert the east/north coordinates to view coordinates.
      * @return The affine transform. It should not be changed.
      * @since 10375

src/org/openstreetmap/josm/gui/dialogs/InspectPrimitiveDataText.java

@@ -202 +202 @@
     }
 
     void addCoordinates(Node n) {
-        if (n.getCoor() != null) {
+        if (n.isLatLonKnown()) {
             add(tr("Coordinates: "),
-                    Double.toString(n.getCoor().lat()), ", ",
-                    Double.toString(n.getCoor().lon()));
+                    Double.toString(n.lat()), ", ",
+                    Double.toString(n.lon()));
             add(tr("Coordinates (projected): "),
                     Double.toString(n.getEastNorth().east()), ", ",
                     Double.toString(n.getEastNorth().north()));

src/org/openstreetmap/josm/gui/draw/MapViewPath.java

@@ -2 +2 @@
 package org.openstreetmap.josm.gui.draw;
 
 import org.openstreetmap.josm.data.coor.EastNorth;
-import org.openstreetmap.josm.data.osm.Node;
+import org.openstreetmap.josm.data.coor.ILatLon;
 import org.openstreetmap.josm.gui.MapViewState;
 import org.openstreetmap.josm.gui.MapViewState.MapViewPoint;
 import org.openstreetmap.josm.gui.mappaint.styleelement.Symbol.SymbolShape;
@@ -29 +29 @@
      * @param n The node
      * @return this for easy chaining.
      */
-    public MapViewPath moveTo(Node n) {
-        moveTo(n.getEastNorth());
+    public MapViewPath moveTo(ILatLon n) {
+        moveTo(n.getEastNorth(state.getProjecting()));
         return this;
     }
 
@@ -55 +55 @@
      * @param n The node
      * @return this for easy chaining.
      */
-    public MapViewPath lineTo(Node n) {
-        lineTo(n.getEastNorth());
+    public MapViewPath lineTo(ILatLon n) {
+        lineTo(n.getEastNorth(state.getProjecting()));
         return this;
     }
 
@@ -83 +83 @@
      * @param size The size of the symbol in pixel
      * @return this for easy chaining.
      */
-    public MapViewPath shapeAround(Node p1, SymbolShape symbol, double size) {
-        shapeAround(p1.getEastNorth(), symbol, size);
+    public MapViewPath shapeAround(ILatLon p1, SymbolShape symbol, double size) {
+        shapeAround(p1.getEastNorth(state.getProjecting()), symbol, size);
         return this;
     }
 
@@ -112 +112 @@
      * @param connect <code>true</code> if we should use a lineTo as first command.
      * @return this for easy chaining.
      */
-    public MapViewPath append(Iterable<Node> nodes, boolean connect) {
+    public MapViewPath append(Iterable<? extends ILatLon> nodes, boolean connect) {
         appendWay(nodes, connect, false);
         return this;
     }
@@ -123 +123 @@
      * @param connect <code>true</code> if we should use a lineTo as first command.
      * @return this for easy chaining.
      */
-    public MapViewPath appendClosed(Iterable<Node> nodes, boolean connect) {
+    public MapViewPath appendClosed(Iterable<? extends ILatLon> nodes, boolean connect) {
         appendWay(nodes, connect, true);
         return this;
     }
 
-    private void appendWay(Iterable<Node> nodes, boolean connect, boolean close) {
+    private void appendWay(Iterable<? extends ILatLon> nodes, boolean connect, boolean close) {
         boolean useMoveTo = !connect;
-        Node first = null;
-        for (Node n : nodes) {
+        ILatLon first = null;
+        for (ILatLon n : nodes) {
             if (useMoveTo) {
                 moveTo(n);
             } else {

src/org/openstreetmap/josm/tools/Geometry.java

@@ -21 +21 @@
 import org.openstreetmap.josm.command.ChangeCommand;
 import org.openstreetmap.josm.command.Command;
 import org.openstreetmap.josm.data.coor.EastNorth;
-import org.openstreetmap.josm.data.coor.LatLon;
 import org.openstreetmap.josm.data.osm.BBox;
 import org.openstreetmap.josm.data.osm.MultipolygonBuilder;
 import org.openstreetmap.josm.data.osm.MultipolygonBuilder.JoinedPolygon;
@@ -218 +217 @@
 
         BBox bounds = new BBox(nodes.get(0));
         for (Node n: nodes) {
-            bounds.add(n.getCoor());
+            bounds.add(n);
         }
         return bounds;
     }
@@ -413 +412 @@
         else if (segmentOnly && offset >= 1)
             return p2;
         else
-            return new EastNorth(p1.getX() + ldx * offset, p1.getY() + ldy * offset);
+            return p1.interpolate(p2, offset);
     }
 
     /**
@@ -510 +509 @@
         boolean begin = true;
         for (Node n : polygon) {
             if (begin) {
-                path.moveTo(n.getCoor().lon(), n.getCoor().lat());
+                path.moveTo(n.lon(), n.lat());
                 begin = false;
             } else {
-                path.lineTo(n.getCoor().lon(), n.getCoor().lat());
+                path.lineTo(n.lon(), n.lat());
             }
         }
         if (!begin) {
@@ -706 +705 @@
         double area2 = 0.;
 
         for (int node = 1; node <= /*sic! consider last-first as well*/ nodesCount; node++) {
-            LatLon coorPrev = nodes.get(node - 1).getCoor();
-            LatLon coorCurr = nodes.get(node % nodesCount).getCoor();
+            Node coorPrev = nodes.get(node - 1);
+            Node coorCurr = nodes.get(node % nodesCount);
             area2 += coorPrev.lon() * coorCurr.lat();
             area2 -= coorCurr.lon() * coorPrev.lat();
         }
@@ -966 +965 @@
         CheckParameterUtil.ensureParameterNotNull(nodes, "nodes");
         double area = 0;
         double perimeter = 0;
+        Projection useProjection = projection == null ? Main.getProjection() : projection;
+
         if (!nodes.isEmpty()) {
             boolean closed = nodes.get(0) == nodes.get(nodes.size() - 1);
             int numSegments = closed ? nodes.size() - 1 : nodes.size();
-            EastNorth p1 = projection == null ? nodes.get(0).getEastNorth() : projection.latlon2eastNorth(nodes.get(0).getCoor());
+            EastNorth p1 = nodes.get(0).getEastNorth(useProjection);
             for (int i = 1; i <= numSegments; i++) {
                 final Node node = nodes.get(i == numSegments ? 0 : i);
-                final EastNorth p2 = projection == null ? node.getEastNorth() : projection.latlon2eastNorth(node.getCoor());
+                final EastNorth p2 = node.getEastNorth(useProjection);
                 if (p1 != null && p2 != null) {
                     area += p1.east() * p2.north() - p2.east() * p1.north();
                     perimeter += p1.distance(p2);

test/unit/org/openstreetmap/josm/data/projection/ShiftedProjectionTest.java

@@ -13 +13 @@
 import org.junit.Test;
 import org.openstreetmap.josm.data.ProjectionBounds;
 import org.openstreetmap.josm.data.coor.EastNorth;
+import org.openstreetmap.josm.data.coor.ILatLon;
 import org.openstreetmap.josm.data.coor.LatLon;
 
 /**
@@ -22 +23 @@
 public class ShiftedProjectionTest {
     private static final class ProjectingBase implements Projecting {
         @Override
-        public EastNorth latlon2eastNorth(LatLon ll) {
+        public EastNorth latlon2eastNorth(ILatLon ll) {
             return new EastNorth(ll.lat() * 2, ll.lon() * 3);
         }
 
@@ -52 +53 @@
     }
 
     /**
-     * Test {@link ShiftedProjecting#latlon2eastNorth(LatLon)}
+     * Test {@link ShiftedProjecting#latlon2eastNorth(ILatLon)}
      */
     @Test
     public void testLatlon2eastNorth() {