Changeset 10805 in josm for trunk/src

Timestamp:

2016-08-15T14:45:38+02:00 (8 years ago)

Author:

Don-vip

Message:

fix #13287 - Projection updates to support multiple projections (patch by michael2402) - gsoc-core

Location:

trunk/src/org/openstreetmap/josm

Files:

• data/projection/AbstractProjection.java (modified) (4 diffs)
• data/projection/Projecting.java (added)
• data/projection/Projection.java (modified) (2 diffs)
• data/projection/ShiftedProjecting.java (added)
• data/projection/proj/Mercator.java (modified) (1 diff)
• data/projection/proj/Proj.java (modified) (1 diff)
• gui/MapViewState.java (modified) (11 diffs)
• gui/layer/AbstractTileSourceLayer.java (modified) (5 diffs)
• gui/layer/imagery/TileCoordinateConverter.java (modified) (4 diffs)
• tools/Utils.java (modified) (1 diff)

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

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.data.projection;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.DoubleUnaryOperator;
 
 import org.openstreetmap.josm.data.Bounds;
@@ -8 +13 @@
 import org.openstreetmap.josm.data.projection.datum.Datum;
 import org.openstreetmap.josm.data.projection.proj.Proj;
+import org.openstreetmap.josm.tools.Utils;
 
 /**
@@ -116 +122 @@
     @Override
     public LatLon eastNorth2latlon(EastNorth en) {
+        return eastNorth2latlon(en, LatLon::normalizeLon);
+    }
+
+    @Override
+    public LatLon eastNorth2latlonClamped(EastNorth en) {
+        LatLon 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()));
+    }
+
+    private LatLon eastNorth2latlon(EastNorth en, DoubleUnaryOperator normalizeLon) {
         double[] latlonRad = proj.invproject((en.east() * toMeter - x0) / ellps.a / k0, (en.north() * toMeter - y0) / ellps.a / k0);
-        LatLon ll = new LatLon(Math.toDegrees(latlonRad[0]), LatLon.normalizeLon(Math.toDegrees(latlonRad[1]) + lon0 + pm));
+        double lon = Math.toDegrees(latlonRad[1]) + lon0 + pm;
+        LatLon ll = new LatLon(Math.toDegrees(latlonRad[0]), normalizeLon.applyAsDouble(lon));
         return datum.toWGS84(ll);
+    }
+
+    @Override
+    public Map<ProjectionBounds, Projecting> getProjectingsForArea(ProjectionBounds area) {
+        if (proj.lonIsLinearToEast()) {
+            //FIXME: Respect datum?
+            // wrap the wrold around
+            Bounds bounds = getWorldBoundsLatLon();
+            double minEast = latlon2eastNorth(bounds.getMin()).east();
+            double maxEast = latlon2eastNorth(bounds.getMax()).east();
+            double dEast = maxEast - minEast;
+            if ((area.minEast < minEast || area.maxEast > maxEast) && dEast > 0) {
+                // We could handle the dEast < 0 case but we don't need it atm.
+                int minChunk = (int) Math.floor((area.minEast - minEast) / dEast);
+                int maxChunk = (int) Math.floor((area.maxEast - minEast) / dEast);
+                HashMap<ProjectionBounds, Projecting> ret = new HashMap<>();
+                for (int chunk = minChunk; chunk <= maxChunk; chunk++) {
+                    ret.put(new ProjectionBounds(Math.max(area.minEast, minEast + chunk * dEast), area.minNorth,
+                            Math.min(area.maxEast, maxEast + chunk * dEast), area.maxNorth),
+                            new ShiftedProjecting(this, new EastNorth(-chunk * dEast, 0)));
+                }
+                return ret;
+            }
+        }
+
+        return Collections.singletonMap(area, this);
     }
 
@@ -179 +224 @@
         return projectionBoundsBox;
     }
+
+    @Override
+    public Projection getBaseProjection() {
+        return this;
+    }
 }

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

@@ -14 +14 @@
  * factor and x/y offset.
  */
-public interface Projection {
+public interface Projection extends Projecting {
     /**
      * The default scale factor in east/north units per pixel
@@ -22 +22 @@
      */
     double getDefaultZoomInPPD();
-
-    /**
-     * Convert from lat/lon to easting/northing.
-     *
-     * @param ll the geographical point to convert (in WGS84 lat/lon)
-     * @return the corresponding east/north coordinates
-     */
-    EastNorth latlon2eastNorth(LatLon ll);
 
     /**

trunk/src/org/openstreetmap/josm/data/projection/proj/Mercator.java

@@ -120 +120 @@
         return scaleFactor;
     }
+
+    @Override
+    public boolean lonIsLinearToEast() {
+        return true;
+    }
 }

trunk/src/org/openstreetmap/josm/data/projection/proj/Proj.java

@@ -91 +91 @@
      */
     boolean isGeographic();
+
+    /**
+     * Checks wether the result of projecting a lon coordinate only has a linear relation to the east coordinate and
+     * is not related to lat/north at all.
+     * @return <code>true</code> if lon has a linear relationship to east only.
+     * @since 10805
+     */
+    default boolean lonIsLinearToEast() {
+        return false;
+    }
 }

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

@@ -17 +17 @@
 import org.openstreetmap.josm.data.coor.EastNorth;
 import org.openstreetmap.josm.data.coor.LatLon;
+import org.openstreetmap.josm.data.projection.Projecting;
 import org.openstreetmap.josm.data.projection.Projection;
 import org.openstreetmap.josm.gui.download.DownloadDialog;
@@ -28 +29 @@
 public final class MapViewState {
 
-    private final Projection projection;
+    private final Projecting projecting;
 
     private final int viewWidth;
@@ -51 +52 @@
      * @param topLeft The top left corner in east/north space.
      */
-    private MapViewState(Projection projection, int viewWidth, int viewHeight, double scale, EastNorth topLeft) {
-        this.projection = projection;
+    private MapViewState(Projecting projection, int viewWidth, int viewHeight, double scale, EastNorth topLeft) {
+        this.projecting = projection;
         this.scale = scale;
         this.topLeft = topLeft;
@@ -63 +64 @@
 
     private MapViewState(EastNorth topLeft, MapViewState mapViewState) {
-        this.projection = mapViewState.projection;
+        this.projecting = mapViewState.projecting;
         this.scale = mapViewState.scale;
         this.topLeft = topLeft;
@@ -74 +75 @@
 
     private MapViewState(double scale, MapViewState mapViewState) {
-        this.projection = mapViewState.projection;
+        this.projecting = mapViewState.projecting;
         this.scale = scale;
         this.topLeft = mapViewState.topLeft;
@@ -85 +86 @@
 
     private MapViewState(JComponent position, MapViewState mapViewState) {
-        this.projection = mapViewState.projection;
+        this.projecting = mapViewState.projecting;
         this.scale = mapViewState.scale;
         this.topLeft = mapViewState.topLeft;
@@ -106 +107 @@
     }
 
-    private MapViewState(Projection projection, MapViewState mapViewState) {
-        this.projection = projection;
+    private MapViewState(Projecting projecting, MapViewState mapViewState) {
+        this.projecting = projecting;
         this.scale = mapViewState.scale;
         this.topLeft = mapViewState.topLeft;
@@ -201 +202 @@
      */
     public Projection getProjection() {
-        return projection;
+        return projecting.getBaseProjection();
     }
 
@@ -269 +270 @@
      */
     public MapViewState usingProjection(Projection projection) {
-        if (projection.equals(this.projection)) {
+        if (projection.equals(this.projecting)) {
             return this;
         } else {
@@ -358 +359 @@
          * Gets the current position in LatLon coordinates according to the current projection.
          * @return The positon as LatLon.
+         * @see #getLatLonClamped()
          */
         public LatLon getLatLon() {
-            return projection.eastNorth2latlon(getEastNorth());
+            return projecting.getBaseProjection().eastNorth2latlon(getEastNorth());
+        }
+
+        /**
+         * Gets the latlon coordinate clamped to the current world area.
+         * @return The lat/lon coordinate
+         * @since 10805
+         */
+        public LatLon getLatLonClamped() {
+            return projecting.eastNorth2latlonClamped(getEastNorth());
         }
 
@@ -474 +485 @@
          */
         public Bounds getLatLonBoundsBox() {
-            return projection.getLatLonBoundsBox(getProjectionBounds());
+            // TODO @michael2402: Use hillclimb.
+            return projecting.getBaseProjection().getLatLonBoundsBox(getProjectionBounds());
         }
 

trunk/src/org/openstreetmap/josm/gui/layer/AbstractTileSourceLayer.java

@@ -231 +231 @@
 
     protected void initTileSource(T tileSource) {
-        coordinateConverter = new TileCoordinateConverter(Main.map.mapView, getDisplaySettings());
+        coordinateConverter = new TileCoordinateConverter(Main.map.mapView, tileSource, getDisplaySettings());
         attribution.initialize(tileSource);
 
@@ -368 +368 @@
      */
     private double getScaleFactor(int zoom) {
-        if (!Main.isDisplayingMapView()) return 1;
-        MapView mv = Main.map.mapView;
-        LatLon topLeft = mv.getLatLon(0, 0);
-        LatLon botRight = mv.getLatLon(mv.getWidth(), mv.getHeight());
-        TileXY t1 = tileSource.latLonToTileXY(topLeft.toCoordinate(), zoom);
-        TileXY t2 = tileSource.latLonToTileXY(botRight.toCoordinate(), zoom);
-
-        int screenPixels = mv.getWidth()*mv.getHeight();
-        double tilePixels = Math.abs((t2.getY()-t1.getY())*(t2.getX()-t1.getX())*tileSource.getTileSize()*tileSource.getTileSize());
-        if (screenPixels == 0 || tilePixels == 0) return 1;
-        return screenPixels/tilePixels;
+        if (coordinateConverter != null) {
+            return coordinateConverter.getScaleFactor(zoom);
+        } else {
+            return 1;
+        }
     }
 
@@ -1246 +1240 @@
 
     private LatLon getShiftedLatLon(EastNorth en) {
-        return Main.getProjection().eastNorth2latlon(en.add(-getDisplaySettings().getDx(), -getDisplaySettings().getDy()));
+        return coordinateConverter.getProjecting().eastNorth2latlonClamped(en);
     }
 
@@ -1520 +1514 @@
     @Override
     public void paint(Graphics2D g, MapView mv, Bounds bounds) {
-        ProjectionBounds pb = mv.getState().getViewArea().getProjectionBounds();
-
-        needRedraw = false;
-
+        // old and unused.
+    }
+
+    private void drawInViewArea(Graphics2D g, MapView mv, ProjectionBounds pb) {
         int zoom = currentZoomLevel;
         if (getDisplaySettings().isAutoZoom()) {
@@ -1898 +1892 @@
             allocateCacheMemory();
             if (memory != null) {
-                super.paint(graphics);
-            }
+                doPaint(graphics);
+            }
+        }
+
+        private void doPaint(MapViewGraphics graphics) {
+            ProjectionBounds pb = graphics.getClipBounds().getProjectionBounds();
+
+            needRedraw = false; // TEMPORARY
+
+            drawInViewArea(graphics.getDefaultGraphics(), graphics.getMapView(), pb);
         }
 

trunk/src/org/openstreetmap/josm/gui/layer/imagery/TileCoordinateConverter.java

@@ -6 +6 @@
 
 import org.openstreetmap.gui.jmapviewer.Tile;
+import org.openstreetmap.gui.jmapviewer.TileXY;
 import org.openstreetmap.gui.jmapviewer.interfaces.ICoordinate;
+import org.openstreetmap.gui.jmapviewer.interfaces.TileSource;
 import org.openstreetmap.josm.data.coor.LatLon;
+import org.openstreetmap.josm.data.projection.Projecting;
+import org.openstreetmap.josm.data.projection.ShiftedProjecting;
 import org.openstreetmap.josm.gui.MapView;
 import org.openstreetmap.josm.gui.MapViewState.MapViewPoint;
@@ -19 +23 @@
     private MapView mapView;
     private TileSourceDisplaySettings settings;
+    private TileSource tileSource;
 
     /**
      * Create a new coordinate converter for the map view.
      * @param mapView The map view.
+     * @param tileSource The tile source to use when converting coordinates.
      * @param settings displacement settings.
      */
-    public TileCoordinateConverter(MapView mapView, TileSourceDisplaySettings settings) {
+    public TileCoordinateConverter(MapView mapView, TileSource tileSource, TileSourceDisplaySettings settings) {
         this.mapView = mapView;
+        this.tileSource = tileSource;
         this.settings = settings;
     }
@@ -32 +39 @@
     private MapViewPoint pos(ICoordinate ll) {
         return mapView.getState().getPointFor(new LatLon(ll)).add(settings.getDisplacement());
+    }
+
+    /**
+     * Gets the projecting instance to use to convert between latlon and eastnorth coordinates.
+     * @return The {@link Projecting} instance.
+     */
+    public Projecting getProjecting() {
+        return new ShiftedProjecting(mapView.getProjection(), settings.getDisplacement());
     }
 
@@ -55 +70 @@
         return pos(c1).rectTo(pos(c2)).getInView();
     }
+
+    /**
+     * Returns average number of screen pixels per tile pixel for current mapview
+     * @param zoom zoom level
+     * @return average number of screen pixels per tile pixel
+     */
+    public double getScaleFactor(int zoom) {
+        LatLon topLeft = mapView.getLatLon(0, 0);
+        LatLon botRight = mapView.getLatLon(mapView.getWidth(), mapView.getHeight());
+        TileXY t1 = tileSource.latLonToTileXY(topLeft.toCoordinate(), zoom);
+        TileXY t2 = tileSource.latLonToTileXY(botRight.toCoordinate(), zoom);
+
+        int screenPixels = mapView.getWidth()*mapView.getHeight();
+        double tilePixels = Math.abs((t2.getY()-t1.getY())*(t2.getX()-t1.getX())*tileSource.getTileSize()*tileSource.getTileSize());
+        if (screenPixels == 0 || tilePixels == 0) return 1;
+        return screenPixels/tilePixels;
+    }
 }

trunk/src/org/openstreetmap/josm/tools/Utils.java

@@ -1552 +1552 @@
         }
     }
+
+    /**
+     * Clamp a value to the given range
+     * @param val The value
+     * @param min minimum value
+     * @param max maximum value
+     * @return the value
+     * @since 10805
+     */
+    public static double clamp(double val, double min, double max) {
+        if (val < min) {
+            return min;
+        } else if (val > max) {
+            return max;
+        } else {
+            return val;
+        }
+    }
 }