Changeset 11858 in josm for trunk/src/org/openstreetmap

Timestamp:

2017-04-09T11:08:10+02:00 (8 years ago)

Author:

bastiK

Message:

fixed #7427 - Support reprojection (warping) of imagery layer

Location:

trunk/src/org/openstreetmap/josm

Files:

• data/imagery/AbstractWMSTileSource.java (modified) (8 diffs)
• data/imagery/ImageryInfo.java (modified) (7 diffs)
• data/imagery/TMSCachedTileLoaderJob.java (modified) (1 diff)
• data/imagery/TemplatedWMSTileSource.java (modified) (4 diffs)
• data/imagery/WMSCachedTileLoaderJob.java (modified) (2 diffs)
• data/imagery/WMTSTileSource.java (modified) (14 diffs)
• data/projection/CustomProjection.java (modified) (1 diff)
• data/projection/Projection.java (modified) (1 diff)
• gui/NavigatableComponent.java (modified) (1 diff)
• gui/layer/AbstractTileSourceLayer.java (modified) (27 diffs)
• gui/layer/ImageryLayer.java (modified) (6 diffs)
• gui/layer/TMSLayer.java (modified) (3 diffs)
• gui/layer/WMSLayer.java (modified) (7 diffs)
• gui/layer/WMTSLayer.java (modified) (4 diffs)
• gui/layer/imagery/ReprojectionTile.java (added)
• gui/layer/imagery/TileCoordinateConverter.java (modified) (5 diffs)
• io/imagery/ImageryReader.java (modified) (1 diff)
• tools/ImageWarp.java (added)

trunk/src/org/openstreetmap/josm/data/imagery/AbstractWMSTileSource.java

@@ -11 +11 @@
 import org.openstreetmap.gui.jmapviewer.tilesources.TMSTileSource;
 import org.openstreetmap.gui.jmapviewer.tilesources.TileSourceInfo;
-import org.openstreetmap.josm.Main;
 import org.openstreetmap.josm.data.Bounds;
 import org.openstreetmap.josm.data.ProjectionBounds;
@@ -32 +31 @@
     private double[] degreesPerTile;
     private static final float SCALE_DENOMINATOR_ZOOM_LEVEL_1 = 559082264.0287178f;
+    private Projection tileProjection;
 
     /**
      * Constructs a new {@code AbstractWMSTileSource}.
      * @param info tile source info
+     * @param tileProjection the tile projection
      */
-    public AbstractWMSTileSource(TileSourceInfo info) {
+    public AbstractWMSTileSource(TileSourceInfo info, Projection tileProjection) {
         super(info);
+        this.tileProjection = tileProjection;
     }
 
@@ -48 +50 @@
     }
 
+    public void setTileProjection(Projection tileProjection) {
+        this.tileProjection = tileProjection;
+        initProjection();
+    }
+
+    public Projection getTileProjection() {
+        return this.tileProjection;
+    }
+
     /**
      * Initializes class with current projection in JOSM. This call is needed every time projection changes.
      */
     public void initProjection() {
-        initProjection(Main.getProjection());
+        initProjection(this.tileProjection);
     }
 
@@ -99 +110 @@
     @Override
     public ICoordinate tileXYToLatLon(int x, int y, int zoom) {
-        return Main.getProjection().eastNorth2latlon(getTileEastNorth(x, y, zoom)).toCoordinate();
+        return tileProjection.eastNorth2latlon(getTileEastNorth(x, y, zoom)).toCoordinate();
     }
 
@@ -112 +123 @@
     @Override
     public TileXY latLonToTileXY(double lat, double lon, int zoom) {
-        EastNorth enPoint = Main.getProjection().latlon2eastNorth(new LatLon(lat, lon));
+        EastNorth enPoint = tileProjection.latlon2eastNorth(new LatLon(lat, lon));
         return eastNorthToTileXY(enPoint, zoom);
     }
@@ -144 +155 @@
     public Point latLonToXY(double lat, double lon, int zoom) {
         double scale = getDegreesPerTile(zoom) / getTileSize();
-        EastNorth point = Main.getProjection().latlon2eastNorth(new LatLon(lat, lon));
+        EastNorth point = tileProjection.latlon2eastNorth(new LatLon(lat, lon));
         return new Point(
                 (int) Math.round((point.east() - anchorPosition.east()) / scale),
@@ -164 +175 @@
     public ICoordinate xyToLatLon(int x, int y, int zoom) {
         double scale = getDegreesPerTile(zoom) / getTileSize();
-        Projection proj = Main.getProjection();
         EastNorth ret = new EastNorth(
                 anchorPosition.east() + x * scale,
                 anchorPosition.north() - y * scale
                 );
-        return proj.eastNorth2latlon(ret).toCoordinate();
+        return tileProjection.eastNorth2latlon(ret).toCoordinate();
     }
 
@@ -197 +207 @@
     @Override
     public String getServerCRS() {
-        return Main.getProjection().toCode();
+        return this.tileProjection.toCode();
     }
 }

trunk/src/org/openstreetmap/josm/data/imagery/ImageryInfo.java

@@ -204 +204 @@
     /** is the geo reference correct - don't offer offset handling */
     private boolean isGeoreferenceValid;
-    /** does the EPSG:4326 to mercator woraround work as expected */
-    private boolean isEpsg4326To3857Supported;
     /** which layers should be activated by default on layer addition. **/
     private Collection<DefaultLayer> defaultLayers = Collections.emptyList();
@@ -244 +242 @@
         @pref boolean valid_georeference;
         @pref boolean bestMarked;
-        @pref boolean supports_epsg_4326_to_3857_conversion;
         // TODO: disabled until change of layers is implemented
         // @pref String default_layers;
@@ -309 +306 @@
 
             valid_georeference = i.isGeoreferenceValid();
-            supports_epsg_4326_to_3857_conversion = i.isEpsg4326To3857Supported();
             // TODO disabled until change of layers is implemented
             // default_layers = i.defaultLayers.stream().collect(Collectors.joining(","));
@@ -439 +435 @@
         setTileSize(e.tileSize);
         metadataHeaders = e.metadataHeaders;
-        isEpsg4326To3857Supported = e.supports_epsg_4326_to_3857_conversion;
         isGeoreferenceValid = e.valid_georeference;
         // TODO disabled until change of layers is implemented
@@ -476 +471 @@
         this.noTileChecksums = i.noTileChecksums;
         this.metadataHeaders = i.metadataHeaders;
-        this.isEpsg4326To3857Supported = i.isEpsg4326To3857Supported;
         this.isGeoreferenceValid = i.isGeoreferenceValid;
         this.defaultLayers = i.defaultLayers;
@@ -506 +500 @@
                 Objects.equals(this.url, other.url) &&
                 Objects.equals(this.bestMarked, other.bestMarked) &&
-                Objects.equals(this.isEpsg4326To3857Supported, other.isEpsg4326To3857Supported) &&
                 Objects.equals(this.isGeoreferenceValid, other.isGeoreferenceValid) &&
                 Objects.equals(this.cookies, other.cookies) &&
@@ -1141 +1134 @@
             this.metadataHeaders = metadataHeaders;
         }
-    }
-
-    /**
-     * Gets the flag if epsg 4326 to 3857 is supported
-     * @return The flag.
-     */
-    public boolean isEpsg4326To3857Supported() {
-        return isEpsg4326To3857Supported;
-    }
-
-    /**
-     * Sets the flag that epsg 4326 to 3857 is supported
-     * @param isEpsg4326To3857Supported The flag.
-     */
-    public void setEpsg4326To3857Supported(boolean isEpsg4326To3857Supported) {
-        this.isEpsg4326To3857Supported = isEpsg4326To3857Supported;
     }
 

trunk/src/org/openstreetmap/josm/data/imagery/TMSCachedTileLoaderJob.java

@@ -46 +46 @@
     private static final LongProperty MAXIMUM_EXPIRES = new LongProperty("imagery.generic.maximum_expires", TimeUnit.DAYS.toMillis(30));
     private static final LongProperty MINIMUM_EXPIRES = new LongProperty("imagery.generic.minimum_expires", TimeUnit.HOURS.toMillis(1));
-    private final Tile tile;
+    protected final Tile tile;
     private volatile URL url;
 

trunk/src/org/openstreetmap/josm/data/imagery/TemplatedWMSTileSource.java

@@ -19 +19 @@
 import org.openstreetmap.josm.data.coor.EastNorth;
 import org.openstreetmap.josm.data.coor.LatLon;
+import org.openstreetmap.josm.data.projection.Projection;
 import org.openstreetmap.josm.gui.layer.WMSLayer;
 import org.openstreetmap.josm.tools.CheckParameterUtil;
@@ -54 +55 @@
      * Creates a tile source based on imagery info
      * @param info imagery info
+     * @param tileProjection the tile projection
      */
-    public TemplatedWMSTileSource(ImageryInfo info) {
-        super(info);
+    public TemplatedWMSTileSource(ImageryInfo info, Projection tileProjection) {
+        super(info, tileProjection);
         this.serverProjections = new TreeSet<>(info.getServerProjections());
         handleTemplate();
@@ -69 +71 @@
     @Override
     public String getTileUrl(int zoom, int tilex, int tiley) {
-        String myProjCode = Main.getProjection().toCode();
+        String myProjCode = getServerCRS();
 
         EastNorth nw = getTileEastNorth(tilex, tiley, zoom);
@@ -79 +81 @@
         double s = se.getY();
         double e = se.getX();
-
-        if (!serverProjections.contains(myProjCode) && serverProjections.contains("EPSG:4326") && "EPSG:3857".equals(myProjCode)) {
-            LatLon swll = Main.getProjection().eastNorth2latlon(new EastNorth(w, s));
-            LatLon nell = Main.getProjection().eastNorth2latlon(new EastNorth(e, n));
-            myProjCode = "EPSG:4326";
-            s = swll.lat();
-            w = swll.lon();
-            n = nell.lat();
-            e = nell.lon();
-        }
 
         if ("EPSG:4326".equals(myProjCode) && !serverProjections.contains(myProjCode) && serverProjections.contains("CRS:84")) {

trunk/src/org/openstreetmap/josm/data/imagery/WMSCachedTileLoaderJob.java

@@ -8 +8 @@
 import org.openstreetmap.gui.jmapviewer.Tile;
 import org.openstreetmap.gui.jmapviewer.interfaces.TileLoaderListener;
-import org.openstreetmap.josm.Main;
 import org.openstreetmap.josm.data.cache.BufferedImageCacheEntry;
 
@@ -40 +39 @@
         String key = super.getCacheKey();
         if (key != null) {
-            return key + Main.getProjection().toCode();
+            return key + tile.getSource().getServerCRS();
         }
         return null;

trunk/src/org/openstreetmap/josm/data/imagery/WMTSTileSource.java

@@ -14 +14 @@
 import java.util.Collection;
 import java.util.Collections;
-import java.util.HashSet;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
@@ -20 +20 @@
 import java.util.Objects;
 import java.util.Optional;
-import java.util.Set;
 import java.util.SortedSet;
 import java.util.Stack;
@@ -62 +61 @@
 
 /**
- * Tile Source handling WMS providers
+ * Tile Source handling WMTS providers
  *
  * @author Wiktor Niesiobędzki
@@ -269 +268 @@
     private final WMTSDefaultLayer defaultLayer;
 
+    private Projection tileProjection;
+
     /**
      * Creates a tile source based on imagery info
@@ -598 +599 @@
      */
     public void initProjection(Projection proj) {
-        // getLayers will return only layers matching the name, if the user already choose the layer
-        // so we will not ask the user again to chose the layer, if he just changes projection
-        Collection<Layer> candidates = getLayers(
-                currentLayer != null ? new WMTSDefaultLayer(currentLayer.identifier, currentLayer.tileMatrixSet.identifier) : defaultLayer,
-                proj.toCode());
-
-        if (candidates.size() > 1 && defaultLayer != null) {
-            candidates = candidates.stream()
-                    .filter(t -> t.tileMatrixSet.identifier.equals(defaultLayer.getTileMatrixSet()))
-                    .collect(Collectors.toList());
-        }
-        if (candidates.size() == 1) {
-            Layer newLayer = candidates.iterator().next();
-            if (newLayer != null) {
-                this.currentTileMatrixSet = newLayer.tileMatrixSet;
-                this.currentLayer = newLayer;
-                Collection<Double> scales = new ArrayList<>(currentTileMatrixSet.tileMatrix.size());
-                for (TileMatrix tileMatrix : currentTileMatrixSet.tileMatrix) {
-                    scales.add(tileMatrix.scaleDenominator * 0.28e-03);
-                }
-                this.nativeScaleList = new ScaleList(scales);
-            }
-        } else if (candidates.size() > 1) {
-            Main.warn("More than one layer WMTS available: {0} for projection {1} and name {2}. Do not know which to process",
-                    candidates.stream().map(x -> x.getUserTitle() + ": " + x.tileMatrixSet.identifier).collect(Collectors.joining(", ")),
-                    proj.toCode(),
-                    currentLayer != null ? currentLayer.getUserTitle() : defaultLayer
-                    );
-        }
-        this.crsScale = getTileSize() * 0.28e-03 / proj.getMetersPerUnit();
+        if (proj.equals(tileProjection))
+            return;
+        List<Layer> matchingLayers = layers.stream().filter(
+                l -> l.identifier.equals(defaultLayer.layerName) && l.tileMatrixSet.crs.equals(proj.toCode()))
+                .collect(Collectors.toList());
+        if (matchingLayers.size() > 1) {
+            this.currentLayer = matchingLayers.stream().filter(
+                    l -> l.tileMatrixSet.identifier.equals(defaultLayer.getTileMatrixSet()))
+                    .findFirst().orElse(null);
+            this.tileProjection = proj;
+        } else if (matchingLayers.size() == 1) {
+            this.currentLayer = matchingLayers.get(0);
+            this.tileProjection = proj;
+        } else {
+            // no tile matrix sets with current projection
+            if (this.currentLayer == null) {
+                this.tileProjection = null;
+                for (Layer layer : layers) {
+                    if (!layer.identifier.equals(defaultLayer.layerName)) {
+                        continue;
+                    }
+                    Projection pr = Projections.getProjectionByCode(layer.tileMatrixSet.crs);
+                    if (pr != null) {
+                        this.currentLayer = layer;
+                        this.tileProjection = pr;
+                        break;
+                    }
+                }
+                if (this.currentLayer == null)
+                    return;
+            } // else: keep currentLayer and tileProjection as is
+        }
+        this.currentTileMatrixSet = this.currentLayer.tileMatrixSet;
+        Collection<Double> scales = new ArrayList<>(currentTileMatrixSet.tileMatrix.size());
+        for (TileMatrix tileMatrix : currentTileMatrixSet.tileMatrix) {
+            scales.add(tileMatrix.scaleDenominator * 0.28e-03);
+        }
+        this.nativeScaleList = new ScaleList(scales);
+        this.crsScale = getTileSize() * 0.28e-03 / this.tileProjection.getMetersPerUnit();
     }
 
@@ -655 +665 @@
         // no support for non-square tiles (tileHeight != tileWidth)
         // and for different tile sizes at different zoom levels
-        Collection<Layer> projLayers = getLayers(null, Main.getProjection().toCode());
+        Collection<Layer> projLayers = getLayers(null, tileProjection.toCode());
         if (!projLayers.isEmpty()) {
             return projLayers.iterator().next().tileMatrixSet.tileMatrix.get(0).tileHeight;
@@ -736 +746 @@
         TileMatrix matrix = getTileMatrix(zoom);
         if (matrix == null) {
-            return Main.getProjection().getWorldBoundsLatLon().getCenter().toCoordinate();
+            return tileProjection.getWorldBoundsLatLon().getCenter().toCoordinate();
         }
         double scale = matrix.scaleDenominator * this.crsScale;
         EastNorth ret = new EastNorth(matrix.topLeftCorner.east() + x * scale, matrix.topLeftCorner.north() - y * scale);
-        return Main.getProjection().eastNorth2latlon(ret).toCoordinate();
+        return tileProjection.eastNorth2latlon(ret).toCoordinate();
     }
 
@@ -750 +760 @@
         }
 
-        Projection proj = Main.getProjection();
-        EastNorth enPoint = proj.latlon2eastNorth(new LatLon(lat, lon));
+        EastNorth enPoint = tileProjection.latlon2eastNorth(new LatLon(lat, lon));
         double scale = matrix.scaleDenominator * this.crsScale;
         return new TileXY(
@@ -766 +775 @@
     @Override
     public int getTileXMax(int zoom) {
-        return getTileXMax(zoom, Main.getProjection());
+        return getTileXMax(zoom, tileProjection);
     }
 
     @Override
     public int getTileYMax(int zoom) {
-        return getTileYMax(zoom, Main.getProjection());
+        return getTileYMax(zoom, tileProjection);
     }
 
@@ -781 +790 @@
         }
         double scale = matrix.scaleDenominator * this.crsScale;
-        EastNorth point = Main.getProjection().latlon2eastNorth(new LatLon(lat, lon));
+        EastNorth point = tileProjection.latlon2eastNorth(new LatLon(lat, lon));
         return new Point(
                     (int) Math.round((point.east() - matrix.topLeftCorner.east()) / scale),
@@ -805 +814 @@
         }
         double scale = matrix.scaleDenominator * this.crsScale;
-        Projection proj = Main.getProjection();
         EastNorth ret = new EastNorth(
                 matrix.topLeftCorner.east() + x * scale,
                 matrix.topLeftCorner.north() - y * scale
                 );
-        LatLon ll = proj.eastNorth2latlon(ret);
+        LatLon ll = tileProjection.eastNorth2latlon(ret);
         return new Coordinate(ll.lat(), ll.lon());
     }
@@ -857 +865 @@
      * @return set of projection codes that this TileSource supports
      */
-    public Set<String> getSupportedProjections() {
-        Set<String> ret = new HashSet<>();
+    public Collection<String> getSupportedProjections() {
+        Collection<String> ret = new LinkedHashSet<>();
         if (currentLayer == null) {
             for (Layer layer: this.layers) {
@@ -910 +918 @@
     public ScaleList getNativeScales() {
         return nativeScaleList;
+    }
+
+    public Projection getTileProjection() {
+        return tileProjection;
     }
 
@@ -978 +990 @@
     @Override
     public String getServerCRS() {
-        return Main.getProjection().toCode();
+        return tileProjection.toCode();
     }
 }

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

@@ -875 +875 @@
         return result;
     }
+
+    @Override
+    public ProjectionBounds getEastNorthBoundsBox(ProjectionBounds box, Projection boxProjection) {
+        final int n = 8;
+        ProjectionBounds result = null;
+        for (int i = 0; i < 4*n; i++) {
+            EastNorth en = latlon2eastNorth(boxProjection.eastNorth2latlon(getPointAlong(i, n, box)));
+            if (result == null) {
+                result = new ProjectionBounds(en);
+            } else {
+                result.extend(en);
+            }
+        }
+        return result;
+    }
 }

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

@@ -87 +87 @@
 
     /**
+     * Get a box in east/north space of this projection, that fully contains an
+     * east/north box of another projection.
+     *
+     * Reprojecting a rectangular box from one projection to another may distort/rotate
+     * the shape of the box, so in general one needs to walk along the boundary
+     * in small steps to get a reliable result.
+     *
+     * This is an approximate method.
+     *
+     * @param box the east/north box given in projection <code>boxProjection</code>
+     * @param boxProjection the projection of <code>box</code>
+     * @return an east/north box in this projection, containing the given box
+     */
+    ProjectionBounds getEastNorthBoundsBox(ProjectionBounds box, Projection boxProjection);
+
+    /**
      * Get the number of meters per unit of this projection. This more
      * defines the scale of the map, than real conversion of unit to meters

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

@@ -638 +638 @@
         mvs = mvs.movedTo(mvs.getCenter(), newCenter);
         Point2D enOrigin = mvs.getPointFor(new EastNorth(0, 0)).getInView();
-        Point2D enOriginAligned = new Point2D.Double(Math.round(enOrigin.getX()), Math.round(enOrigin.getY()));
+        // as a result of the alignment, it is common to round "half integer" values
+        // like 1.49999, which is numerically unstable; add small epsilon to resolve this
+        double EPSILON = 1e-3;
+        Point2D enOriginAligned = new Point2D.Double(
+                Math.round(enOrigin.getX()) + EPSILON,
+                Math.round(enOrigin.getY()) + EPSILON);
         EastNorth enShift = mvs.getForView(enOriginAligned.getX(), enOriginAligned.getY()).getEastNorth();
         newCenter = newCenter.subtract(enShift);

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

@@ -49 +49 @@
 import javax.swing.AbstractAction;
 import javax.swing.Action;
-import javax.swing.BorderFactory;
 import javax.swing.JCheckBoxMenuItem;
 import javax.swing.JLabel;
@@ -57 +56 @@
 import javax.swing.JPopupMenu;
 import javax.swing.JSeparator;
-import javax.swing.JTextField;
 import javax.swing.Timer;
 
@@ -88 +86 @@
 import org.openstreetmap.josm.data.osm.visitor.BoundingXYVisitor;
 import org.openstreetmap.josm.data.preferences.IntegerProperty;
+import org.openstreetmap.josm.data.projection.Projection;
+import org.openstreetmap.josm.data.projection.Projections;
 import org.openstreetmap.josm.gui.ExtendedDialog;
 import org.openstreetmap.josm.gui.MapFrame;
@@ -96 +96 @@
 import org.openstreetmap.josm.gui.dialogs.LayerListPopup;
 import org.openstreetmap.josm.gui.layer.imagery.ImageryFilterSettings.FilterChangeListener;
+import org.openstreetmap.josm.gui.layer.imagery.ReprojectionTile;
 import org.openstreetmap.josm.gui.layer.imagery.TileAnchor;
 import org.openstreetmap.josm.gui.layer.imagery.TileCoordinateConverter;
@@ -109 +110 @@
 import org.openstreetmap.josm.tools.MemoryManager.MemoryHandle;
 import org.openstreetmap.josm.tools.MemoryManager.NotEnoughMemoryException;
+import org.openstreetmap.josm.tools.Utils;
 
 /**
@@ -185 +187 @@
     private final ImageryAdjustAction adjustAction = new ImageryAdjustAction(this);
     // prepared to be moved to the painter
-    private TileCoordinateConverter coordinateConverter;
+    protected TileCoordinateConverter coordinateConverter;
 
     /**
@@ -346 +348 @@
     public Object getInfoComponent() {
         JPanel panel = (JPanel) super.getInfoComponent();
+        List<List<String>> content = new ArrayList<>();
         EastNorth offset = getDisplaySettings().getDisplacement();
         if (offset.distanceSq(0, 0) > 1e-10) {
-            panel.add(new JLabel(tr("Offset: ") + offset.east() + ';' + offset.north()), GBC.eol().insets(0, 5, 10, 0));
+            content.add(Arrays.asList(tr("Offset"), offset.east() + ";" + offset.north()));
+        }
+        if (coordinateConverter.requiresReprojection()) {
+            content.add(Arrays.asList(tr("Tile download projection"), tileSource.getServerCRS()));
+            content.add(Arrays.asList(tr("Tile display projection"), Main.getProjection().toCode()));
+        }
+        content.add(Arrays.asList(tr("Current zoom"), Integer.toString(currentZoomLevel)));
+        for (List<String> entry: content) {
+            panel.add(new JLabel(entry.get(0) + ':'), GBC.std());
+            panel.add(GBC.glue(5, 0), GBC.std());
+            panel.add(createTextField(entry.get(1)), GBC.eol().fill(GBC.HORIZONTAL));
         }
         return panel;
@@ -363 +376 @@
      * @return average number of screen pixels per tile pixel
      */
-    private double getScaleFactor(int zoom) {
+    protected double getScaleFactor(int zoom) {
         if (coordinateConverter != null) {
             return coordinateConverter.getScaleFactor(zoom);
@@ -384 +397 @@
          */
         int intResult = (int) Math.round(result + 1 + ZOOM_OFFSET.get() / 1.9);
-
-        intResult = Math.min(intResult, getMaxZoomLvl());
-        intResult = Math.max(intResult, getMinZoomLvl());
+        intResult = Utils.clamp(intResult, getMinZoomLvl(), getMaxZoomLvl());
         return intResult;
     }
@@ -398 +409 @@
         private ShowTileInfoAction() {
             super(tr("Show tile info"));
+            setEnabled(clickedTileHolder.getTile() != null);
         }
 
         private String getSizeString(int size) {
             return new StringBuilder().append(size).append('x').append(size).toString();
-        }
-
-        private JTextField createTextField(String text) {
-            JTextField ret = new JTextField(text);
-            ret.setEditable(false);
-            ret.setBorder(BorderFactory.createEmptyBorder());
-            return ret;
         }
 
@@ -426 +431 @@
                 }
 
-                String[][] content = {
-                        {"Tile name", clickedTile.getKey()},
-                        {"Tile url", url},
-                        {"Tile size", getSizeString(clickedTile.getTileSource().getTileSize()) },
-                        {"Tile display size", new StringBuilder().append(displaySize.getWidth())
-                                                                 .append('x')
-                                                                 .append(displaySize.getHeight()).toString()},
-                };
-
-                for (String[] entry: content) {
-                    panel.add(new JLabel(tr(entry[0]) + ':'), GBC.std());
+                List<List<String>> content = new ArrayList<>();
+                content.add(Arrays.asList(tr("Tile name"), clickedTile.getKey()));
+                content.add(Arrays.asList(tr("Tile URL"), url));
+                content.add(Arrays.asList(tr("Tile size"),
+                        getSizeString(clickedTile.getTileSource().getTileSize())));
+                content.add(Arrays.asList(tr("Tile display size"),
+                        new StringBuilder().append(displaySize.getWidth())
+                                .append('x')
+                                .append(displaySize.getHeight()).toString()));
+                if (coordinateConverter.requiresReprojection()) {
+                    content.add(Arrays.asList(tr("Reprojection"),
+                            clickedTile.getTileSource().getServerCRS() +
+                            " -> " + Main.getProjection().toCode()));
+                    BufferedImage img = clickedTile.getImage();
+                    if (img != null) {
+                        content.add(Arrays.asList(tr("Reprojected tile size"),
+                            img.getWidth() + "x" + img.getHeight()));
+
+                    }
+                }
+                for (List<String> entry: content) {
+                    panel.add(new JLabel(entry.get(0) + ':'), GBC.std());
                     panel.add(GBC.glue(5, 0), GBC.std());
-                    panel.add(createTextField(entry[1]), GBC.eol().fill(GBC.HORIZONTAL));
+                    panel.add(createTextField(entry.get(1)), GBC.eol().fill(GBC.HORIZONTAL));
                 }
 
@@ -462 +478 @@
         private LoadTileAction() {
             super(tr("Load tile"));
+            setEnabled(clickedTileHolder.getTile() != null);
         }
 
@@ -946 +963 @@
         Tile tile = getTile(x, y, zoom);
         if (tile == null) {
-            tile = new Tile(tileSource, x, y, zoom);
+            if (coordinateConverter.requiresReprojection()) {
+                tile = new ReprojectionTile(tileSource, x, y, zoom);
+            } else {
+                tile = new Tile(tileSource, x, y, zoom);
+            }
             tileCache.addTile(tile);
         }
@@ -1021 +1042 @@
 
     /**
-     * Invalidate the layer at a time in the future so taht the user still sees the interface responsive.
+     * Invalidate the layer at a time in the future so that the user still sees the interface responsive.
      */
     private void invalidateLater() {
@@ -1055 +1076 @@
     }
 
-    /**
+     /**
      * Draw a tile image on screen.
      * @param g the Graphics2D
@@ -1066 +1087 @@
         AffineTransform imageToScreen = anchorImage.convert(anchorScreen);
         Point2D screen0 = imageToScreen.transform(new Point.Double(0, 0), null);
-        Point2D screen1 = imageToScreen.transform(new Point.Double(toDrawImg.getWidth(), toDrawImg.getHeight()), null);
+        Point2D screen1 = imageToScreen.transform(new Point.Double(
+                toDrawImg.getWidth(), toDrawImg.getHeight()), null);
+
         Shape oldClip = null;
         if (clip != null) {
@@ -1085 +1108 @@
             boolean miss = false;
             BufferedImage img = null;
+            TileAnchor anchorImage = null;
             if (!tile.isLoaded() || tile.hasError()) {
                 miss = true;
             } else {
-                img = getLoadedTileImage(tile);
-                if (img == null) {
+                synchronized (tile) {
+                    img = getLoadedTileImage(tile);
+                    anchorImage = getAnchor(tile, img);
+                }
+                if (img == null || anchorImage == null) {
                     miss = true;
                 }
@@ -1097 +1124 @@
                 return;
             }
-            TileAnchor anchorImage = new TileAnchor(
-                    new Point.Double(0, 0),
-                    new Point.Double(img.getWidth(), img.getHeight()));
-            img = applyImageProcessors((BufferedImage) img);
+
+            img = applyImageProcessors(img);
+
             TileAnchor anchorScreen = coordinateConverter.getScreenAnchorForTile(tile);
             synchronized (paintMutex) {
@@ -1106 +1132 @@
                 drawImageInside(g, img, anchorImage, anchorScreen, null);
             }
+            if (tile instanceof ReprojectionTile) {
+                // This means we have a reprojected tile in memory cache, but not at
+                // current scale. Generally, the positioning of the tile will still
+                // be correct, but for best image quality, the tile should be
+                // reprojected to the target scale. The original tile image should
+                // still be in disk cache, so this is fairly cheap.
+                if (((ReprojectionTile) tile).needsUpdate(Main.map.mapView.getScale())) {
+                    loadTile(tile, true);
+                }
+            }
+
         }, missed::add);
 
@@ -1128 +1165 @@
             boolean miss = false;
             BufferedImage img = null;
+            TileAnchor anchorImage = null;
             if (!tile.isLoaded() || tile.hasError()) {
                 miss = true;
             } else {
-                img = getLoadedTileImage(tile);
-                if (img == null) {
+                synchronized (tile) {
+                    img = getLoadedTileImage(tile);
+                    anchorImage = getAnchor(tile, img);
+                }
+
+                if (img == null || anchorImage == null) {
                     miss = true;
                 }
@@ -1140 +1182 @@
                 continue;
             }
-            TileAnchor anchorImage = new TileAnchor(
-                    new Point.Double(0, 0),
-                    new Point.Double(img.getWidth(), img.getHeight()));
 
             // applying all filters to this layer
@@ -1159 +1198 @@
         }
         return missedTiles;
+    }
+
+    private TileAnchor getAnchor(Tile tile, BufferedImage image) {
+        if (tile instanceof ReprojectionTile) {
+            return ((ReprojectionTile) tile).getAnchor();
+        } else {
+            return new TileAnchor(new Point.Double(0, 0), new Point.Double(image.getWidth(), image.getHeight()));
+        }
     }
 
@@ -1188 +1235 @@
     }
 
-    private void paintTileText(Tile tile, Graphics g, MapView mv) {
+    private void paintTileText(Tile tile, Graphics2D g) {
         if (tile == null) {
             return;
@@ -1218 +1265 @@
         }
 
-        int xCursor = -1;
-        int yCursor = -1;
         if (Main.isDebugEnabled()) {
-            if (yCursor < tile.getYtile()) {
-                if (Math.abs(tile.getYtile() % 32) == 31) {
-                    g.fillRect(0, y - 1, mv.getWidth(), 3);
-                } else {
-                    g.drawLine(0, y, mv.getWidth(), y);
-                }
-                //yCursor = t.getYtile();
-            }
-            // This draws the vertical lines for the entire column. Only draw them for the top tile in the column.
-            if (xCursor < tile.getXtile()) {
-                if (tile.getXtile() % 32 == 0) {
-                    // level 7 tile boundary
-                    g.fillRect(x - 1, 0, 3, mv.getHeight());
-                } else {
-                    g.drawLine(x, 0, x, mv.getHeight());
-                }
-                //xCursor = t.getXtile();
-            }
+            // draw tile outline in semi-transparent red
+            g.setColor(new Color(255, 0, 0, 50));
+            g.draw(coordinateConverter.getScreenQuadrilateralForTile(tile));
         }
     }
@@ -1397 +1427 @@
      */
     protected TileSet getTileSet(ProjectionBounds bounds, int zoom) {
-        IProjected topLeftUnshifted = coordinateConverter.shiftDisplayToServer(bounds.getMin());
-        IProjected botRightUnshifted = coordinateConverter.shiftDisplayToServer(bounds.getMax());
-        TileXY t1 = tileSource.projectedToTileXY(topLeftUnshifted, zoom);
-        TileXY t2 = tileSource.projectedToTileXY(botRightUnshifted, zoom);
+        if (zoom == 0)
+            return new TileSet();
+        TileXY t1, t2;
+        if (coordinateConverter.requiresReprojection()) {
+            Projection projCurrent = Main.getProjection();
+            Projection projServer = Projections.getProjectionByCode(tileSource.getServerCRS());
+            bounds = new ProjectionBounds(
+                    new EastNorth(coordinateConverter.shiftDisplayToServer(bounds.getMin())),
+                    new EastNorth(coordinateConverter.shiftDisplayToServer(bounds.getMax())));
+            bounds = projServer.getEastNorthBoundsBox(bounds, projCurrent);
+            t1 = tileSource.projectedToTileXY(bounds.getMin().toProjected(), zoom);
+            t2 = tileSource.projectedToTileXY(bounds.getMax().toProjected(), zoom);
+        } else {
+            IProjected topLeftUnshifted = coordinateConverter.shiftDisplayToServer(bounds.getMin());
+            IProjected botRightUnshifted = coordinateConverter.shiftDisplayToServer(bounds.getMax());
+            t1 = tileSource.projectedToTileXY(topLeftUnshifted, zoom);
+            t2 = tileSource.projectedToTileXY(botRightUnshifted, zoom);
+        }
         return new TileSet(t1, t2, zoom);
     }
@@ -1593 +1637 @@
         // The current zoom tileset should have all of its tiles due to the loadAllTiles(), unless it to tooLarge()
         for (Tile t : ts.allExistingTiles()) {
-            this.paintTileText(t, g, mv);
+            this.paintTileText(t, g);
         }
 
@@ -1640 +1684 @@
             Main.debug("getTileForPixelpos("+px+", "+py+')');
         }
-        Point clicked = new Point(px, py);
-        TileSet ts = getVisibleTileSet();
-
-        if (!ts.tooLarge()) {
-            ts.loadAllTiles(false); // make sure there are tile objects for all tiles
-        }
-        Stream<Tile> clickedTiles = ts.allExistingTiles().stream()
-                .filter(t -> coordinateConverter.getRectangleForTile(t).contains(clicked));
-        if (Main.isTraceEnabled()) {
-            clickedTiles = clickedTiles.peek(t -> Main.trace("Clicked on tile: " + t.getXtile() + ' ' + t.getYtile() +
-                    " currentZoomLevel: " + currentZoomLevel));
-        }
-        return clickedTiles.findAny().orElse(null);
+        TileXY xy = coordinateConverter.getTileforPixel(px, py, currentZoomLevel);
+        return getTile(xy.getXIndex(), xy.getYIndex(), currentZoomLevel);
     }
 

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

@@ -2 +2 @@
 package org.openstreetmap.josm.gui.layer;
 
-import static org.openstreetmap.josm.tools.I18n.tr;
 import static org.openstreetmap.josm.tools.I18n.trc;
 
@@ -11 +10 @@
 import java.awt.image.BufferedImageOp;
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
 import java.util.List;
 
 import javax.swing.AbstractAction;
 import javax.swing.Action;
+import javax.swing.BorderFactory;
 import javax.swing.Icon;
 import javax.swing.JCheckBoxMenuItem;
@@ -24 +26 @@
 import javax.swing.JPopupMenu;
 import javax.swing.JSeparator;
+import javax.swing.JTextField;
 
 import org.openstreetmap.josm.Main;
@@ -33 +36 @@
 import org.openstreetmap.josm.gui.layer.imagery.ImageryFilterSettings;
 import org.openstreetmap.josm.gui.layer.imagery.TileSourceDisplaySettings;
-import org.openstreetmap.josm.gui.widgets.UrlLabel;
 import org.openstreetmap.josm.tools.GBC;
+import static org.openstreetmap.josm.tools.I18n.tr;
 import org.openstreetmap.josm.tools.ImageProvider;
 import org.openstreetmap.josm.tools.ImageProvider.ImageSizes;
@@ -146 +149 @@
     public void mergeFrom(Layer from) {
     }
+    
+    public abstract Collection<String> getNativeProjections();
 
     @Override
@@ -152 +157 @@
         panel.add(new JLabel(getToolTipText()), GBC.eol());
         if (info != null) {
-            String url = info.getUrl();
-            if (url != null) {
-                panel.add(new JLabel(tr("URL: ")), GBC.std().insets(0, 5, 2, 0));
-                panel.add(new UrlLabel(url), GBC.eol().insets(2, 5, 10, 0));
+            List<List<String>> content = new ArrayList<>();
+            content.add(Arrays.asList(tr("Name"), info.getName()));
+            content.add(Arrays.asList(tr("Type"), info.getImageryType().getTypeString().toUpperCase()));
+            content.add(Arrays.asList(tr("URL"), info.getUrl()));
+            content.add(Arrays.asList(tr("Id"), info.getId() == null ? "-" : info.getId()));
+            if (info.getMinZoom() != 0) {
+                content.add(Arrays.asList(tr("Min. zoom"), Integer.toString(info.getMinZoom())));
+            }
+            if (info.getMaxZoom() != 0) {
+                content.add(Arrays.asList(tr("Max. zoom"), Integer.toString(info.getMaxZoom())));
+            }
+            if (info.getDescription() != null) {
+                content.add(Arrays.asList(tr("Description"), info.getDescription()));
+            }
+            content.add(Arrays.asList(tr("Native projections"), Utils.join(", ", getNativeProjections())));
+            for (List<String> entry: content) {
+                panel.add(new JLabel(entry.get(0) + ':'), GBC.std());
+                panel.add(GBC.glue(5, 0), GBC.std());
+                panel.add(createTextField(entry.get(1)), GBC.eol().fill(GBC.HORIZONTAL));
             }
         }
         return panel;
+    }
+
+    protected JTextField createTextField(String text) {
+        JTextField ret = new JTextField(text);
+        ret.setEditable(false);
+        ret.setBorder(BorderFactory.createEmptyBorder());
+        return ret;
     }
 

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

@@ -6 +6 @@
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
 
 import org.apache.commons.jcs.access.CacheAccess;
@@ -79 +81 @@
 
     @Override
-    public final boolean isProjectionSupported(Projection proj) {
-        return "EPSG:3857".equals(proj.toCode()) || "EPSG:4326".equals(proj.toCode());
-    }
-
-    @Override
-    public final String nameSupportedProjections() {
-        return tr("EPSG:4326 and Mercator projection are supported");
+    public Collection<String> getNativeProjections() {
+        return Collections.singletonList("EPSG:3857");
     }
 
@@ -161 +158 @@
         return new ScaleList(scales);
     }
- }
+}

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

@@ -7 +7 @@
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.List;
-import java.util.Set;
-import java.util.TreeSet;
+import java.util.Objects;
 
 import javax.swing.AbstractAction;
@@ -28 +28 @@
 import org.openstreetmap.josm.data.preferences.IntegerProperty;
 import org.openstreetmap.josm.data.projection.Projection;
+import org.openstreetmap.josm.data.projection.Projections;
 import org.openstreetmap.josm.gui.ExtendedDialog;
 import org.openstreetmap.josm.gui.layer.imagery.TileSourceDisplaySettings;
@@ -55 +56 @@
     private static final String CACHE_REGION_NAME = "WMS";
 
-    private final Set<String> supportedProjections;
+    private final List<String> serverProjections;
 
     /**
@@ -66 +67 @@
         CheckParameterUtil.ensureParameterNotNull(info.getUrl(), "info.url");
         TemplatedWMSTileSource.checkUrl(info.getUrl());
-        this.supportedProjections = new TreeSet<>(info.getServerProjections());
+        this.serverProjections = new ArrayList<>(info.getServerProjections());
     }
 
@@ -87 +88 @@
     @Override
     protected AbstractWMSTileSource getTileSource() {
-        AbstractWMSTileSource tileSource = new TemplatedWMSTileSource(info);
+        AbstractWMSTileSource tileSource = new TemplatedWMSTileSource(
+                info, chooseProjection(Main.getProjection()));
         info.setAttribution(tileSource);
         return tileSource;
@@ -112 +114 @@
 
     @Override
-    public boolean isProjectionSupported(Projection proj) {
-        return supportedProjections == null || supportedProjections.isEmpty() || supportedProjections.contains(proj.toCode()) ||
-                (info.isEpsg4326To3857Supported() && supportedProjections.contains("EPSG:4326")
-                        && "EPSG:3857".equals(Main.getProjection().toCode()));
-    }
-
-    @Override
-    public String nameSupportedProjections() {
-        StringBuilder ret = new StringBuilder();
-        for (String e: supportedProjections) {
-            ret.append(e).append(", ");
-        }
-        String appendix = "";
-
-        if (isReprojectionPossible()) {
-            appendix = ". <p>" + tr("JOSM will use EPSG:4326 to query the server, but results may vary "
-                    + "depending on the WMS server") + "</p>";
-        }
-        return ret.substring(0, ret.length()-2) + appendix;
+    public Collection<String> getNativeProjections() {
+        return serverProjections;
     }
 
     @Override
     public void projectionChanged(Projection oldValue, Projection newValue) {
-        // do not call super - we need custom warning dialog
+        Projection tileProjection = chooseProjection(newValue);
+        if (!Objects.equals(tileSource.getTileProjection(), tileProjection)) {
+            tileSource.setTileProjection(tileProjection);
+        }
+    }
 
-        if (!isProjectionSupported(newValue)) {
-            String message =
-                    "<html><body><p>" + tr("The layer {0} does not support the new projection {1}.",
-                            Utils.escapeReservedCharactersHTML(getName()), newValue.toCode()) +
-                    "<p style='width: 450px; position: absolute; margin: 0px;'>" +
-                            tr("Supported projections are: {0}", nameSupportedProjections()) + "</p>" +
-                    "<p>" + tr("Change the projection again or remove the layer.");
-
-            ExtendedDialog warningDialog = new ExtendedDialog(Main.parent, tr("Warning"), new String[]{tr("OK")}).
-                    setContent(message).
-                    setIcon(JOptionPane.WARNING_MESSAGE);
-
-            if (isReprojectionPossible()) {
-                warningDialog.toggleEnable("imagery.wms.projectionSupportWarnings." + tileSource.getBaseUrl());
+    private Projection chooseProjection(Projection requested) {
+        if (serverProjections.contains(requested.toCode())) {
+            return requested;
+        } else {
+            for (String code : serverProjections) {
+                Projection proj = Projections.getProjectionByCode(code);
+                if (proj != null) {
+                    Main.info(tr("Reprojecting layer {0} from {1} to {2}. For best image quality and performance,"
+                            + " switch to one of the supported projections: {3}",
+                            getName(), proj.toCode(), Main.getProjection().toCode(), Utils.join(", ", getNativeProjections())));
+                    return proj;
+                }
             }
-            warningDialog.showDialog();
-        }
-
-        if (!newValue.equals(oldValue)) {
-            tileSource.initProjection(newValue);
+            Main.warn(tr("Unable to find supported projection for layer {0}. Using {1}.", getName(), requested.toCode()));
+            return requested;
         }
     }
@@ -176 +160 @@
         return AbstractCachedTileSourceLayer.getCache(CACHE_REGION_NAME);
     }
-
-    private boolean isReprojectionPossible() {
-        return supportedProjections.contains("EPSG:4326") && "EPSG:3857".equals(Main.getProjection().toCode());
-    }
 }

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

@@ -3 +3 @@
 
 import java.io.IOException;
-import java.util.Set;
+import java.util.Collection;
 
 import org.apache.commons.jcs.access.CacheAccess;
@@ -15 +15 @@
 import org.openstreetmap.josm.data.projection.Projection;
 import org.openstreetmap.josm.gui.layer.imagery.TileSourceDisplaySettings;
+import org.openstreetmap.josm.tools.Utils;
 
 /**
@@ -75 +76 @@
             return getMaxZoomLvl();
         }
-        double displayScale = Main.map.mapView.getScale() * Main.getProjection().getMetersPerUnit(); // meter per pixel
+        double displayScale = Main.map.mapView.getScale();
+        if (coordinateConverter.requiresReprojection()) {
+            displayScale *= Main.getProjection().getMetersPerUnit();
+        }
         Scale snap = scaleList.getSnapScale(displayScale, false);
-        return Math.max(
-                getMinZoomLvl(),
-                Math.min(
-                        snap != null ? snap.getIndex() : getMaxZoomLvl(),
-                        getMaxZoomLvl()
-                        )
-                );
+        return Utils.clamp(snap != null ? snap.getIndex() : getMaxZoomLvl(),
+                getMinZoomLvl(), getMaxZoomLvl());
     }
 
@@ -92 +91 @@
 
     @Override
-    public boolean isProjectionSupported(Projection proj) {
-        Set<String> supportedProjections = tileSource.getSupportedProjections();
-        return supportedProjections.contains(proj.toCode());
-    }
-
-    @Override
-    public String nameSupportedProjections() {
-        StringBuilder ret = new StringBuilder();
-        for (String e: tileSource.getSupportedProjections()) {
-            ret.append(e).append(", ");
-        }
-        return ret.length() > 2 ? ret.substring(0, ret.length()-2) : ret.toString();
+    public Collection<String> getNativeProjections() {
+        return tileSource.getSupportedProjections();
     }
 

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

@@ -12 +12 @@
 import org.openstreetmap.gui.jmapviewer.interfaces.IProjected;
 import org.openstreetmap.gui.jmapviewer.interfaces.TileSource;
+import org.openstreetmap.josm.Main;
 import org.openstreetmap.josm.data.coor.EastNorth;
 import org.openstreetmap.josm.data.coor.LatLon;
@@ -85 +86 @@
      */
     public Point2D getPixelForTile(Tile tile) {
-        return this.getPixelForTile(tile.getXtile(), tile.getYtile(), tile.getZoom());
+        return getPixelForTile(tile.getXtile(), tile.getYtile(), tile.getZoom());
+    }
+
+    /**
+     * Convert screen pixel coordinate to tile position at certain zoom level.
+     * @param sx x coordinate (screen pixel)
+     * @param sy y coordinate (screen pixel)
+     * @param zoom zoom level
+     * @return the tile
+     */
+    public TileXY getTileforPixel(int sx, int sy, int zoom) {
+        if (requiresReprojection()) {
+            LatLon ll = getProjecting().eastNorth2latlonClamped(mapView.getEastNorth(sx, sy));
+            return tileSource.latLonToTileXY(ll.toCoordinate(), zoom);
+        } else {
+            IProjected p = shiftDisplayToServer(mapView.getEastNorth(sx, sy));
+            return tileSource.projectedToTileXY(p, zoom);
+        }
     }
 
@@ -91 +109 @@
      * Gets the position of the tile inside the map view.
      * @param tile The tile
-     * @return The positon.
+     * @return The positon as a rectangle in screen coordinates
      */
     public Rectangle2D getRectangleForTile(Tile tile) {
@@ -130 +148 @@
      */
     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);
-
+        TileXY t1, t2;
+        if (requiresReprojection()) {
+            LatLon topLeft = mapView.getLatLon(0, 0);
+            LatLon botRight = mapView.getLatLon(mapView.getWidth(), mapView.getHeight());
+            t1 = tileSource.latLonToTileXY(topLeft.toCoordinate(), zoom);
+            t2 = tileSource.latLonToTileXY(botRight.toCoordinate(), zoom);
+        }  else {
+            EastNorth topLeftEN = mapView.getEastNorth(0, 0);
+            EastNorth botRightEN = mapView.getEastNorth(mapView.getWidth(), mapView.getHeight());
+            t1 = tileSource.projectedToTileXY(topLeftEN.toProjected(), zoom);
+            t2 = tileSource.projectedToTileXY(botRightEN.toProjected(), zoom);
+        }
         int screenPixels = mapView.getWidth()*mapView.getHeight();
         double tilePixels = Math.abs((t2.getY()-t1.getY())*(t2.getX()-t1.getX())*tileSource.getTileSize()*tileSource.getTileSize());
@@ -147 +172 @@
      */
     public TileAnchor getScreenAnchorForTile(Tile tile) {
-        IProjected p1 = tileSource.tileXYtoProjected(tile.getXtile(), tile.getYtile(), tile.getZoom());
-        IProjected p2 = tileSource.tileXYtoProjected(tile.getXtile() + 1, tile.getYtile() + 1, tile.getZoom());
-        return new TileAnchor(pos(p1).getInView(), pos(p2).getInView());
+        if (requiresReprojection()) {
+            ICoordinate c1 = tile.getTileSource().tileXYToLatLon(tile);
+            ICoordinate c2 = tile.getTileSource().tileXYToLatLon(tile.getXtile() + 1, tile.getYtile() + 1, tile.getZoom());
+            return new TileAnchor(pos(c1).getInView(), pos(c2).getInView());
+        } else {
+            IProjected p1 = tileSource.tileXYtoProjected(tile.getXtile(), tile.getYtile(), tile.getZoom());
+            IProjected p2 = tileSource.tileXYtoProjected(tile.getXtile() + 1, tile.getYtile() + 1, tile.getZoom());
+            return new TileAnchor(pos(p1).getInView(), pos(p2).getInView());
+        }
+    }
+
+    /**
+     * Return true if tiles need to be reprojected from server projection to display projection.
+     * @return true if tiles need to be reprojected from server projection to display projection
+     */
+    public boolean requiresReprojection() {
+        return !tileSource.getServerCRS().equals(Main.getProjection().toCode());
     }
 }

trunk/src/org/openstreetmap/josm/io/imagery/ImageryReader.java

@@ -458 +458 @@
                     entry.setGeoreferenceValid(Boolean.parseBoolean(accumulator.toString()));
                     break;
-                case "epsg4326to3857Supported":
-                    entry.setEpsg4326To3857Supported(Boolean.parseBoolean(accumulator.toString()));
-                    break;
                 default: // Do nothing
                 }