Ticket #13210: patch-mapview-imagery-tile-source-coordinates.patch

src/org/openstreetmap/gui/jmapviewer/interfaces/TileLoaderListener.java

@@ -3 +3 @@
 
 import org.openstreetmap.gui.jmapviewer.Tile;
 
+/**
+ * This listener listens to successful tile loads.
+ */
+@FunctionalInterface
 public interface TileLoaderListener {
 
     /**

src/org/openstreetmap/josm/data/imagery/CachedTileLoaderFactory.java

@@ -59 +59 @@
     }
 
     @Override
-    public TileLoader makeTileLoader(TileLoaderListener listener) {
-        return makeTileLoader(listener, null);
-    }
-
-    @Override
     public TileLoader makeTileLoader(TileLoaderListener listener, Map<String, String> inputHeaders) {
         Map<String, String> headers = new ConcurrentHashMap<>();
         headers.put("User-Agent", Version.getInstance().getFullAgentString());

src/org/openstreetmap/josm/data/imagery/TileLoaderFactory.java

@@ -12 +12 @@
  * @author Wiktor Niesiobędzki
  * @since 8526
  */
+@FunctionalInterface
 public interface TileLoaderFactory {
 
     /**
      * @param listener that will be notified, when tile has finished loading
      * @return TileLoader that notifies specified listener
+     * @deprecated Use {@link #makeTileLoader(TileLoaderListener, Map)}
      */
-    TileLoader makeTileLoader(TileLoaderListener listener);
+    @Deprecated
+    default TileLoader makeTileLoader(TileLoaderListener listener) {
+        return makeTileLoader(listener, null);
+    }
 
     /**
      * @param listener that will be notified, when tile has finished loading
-     * @param headers that will be sent with requests to TileSource
+     * @param headers that will be sent with requests to TileSource. <code>null</code> indicates none
      * @return TileLoader that uses both of above
      */
     TileLoader makeTileLoader(TileLoaderListener listener, Map<String, String> headers);

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

@@ -7 +7 @@
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Point2D;
 import java.awt.geom.Point2D.Double;
+import java.awt.geom.Rectangle2D;
 
 import javax.swing.JComponent;
 
@@ -143 +144 @@
     }
 
     /**
+     * Gets the {@link MapViewPoint} for the given {@link LatLon} coordinate.
+     * @param latlon the position
+     * @return The point for that position.
+     */
+    public MapViewPoint getPointFor(LatLon latlon) {
+        return getPointFor(getProjection().latlon2eastNorth(latlon));
+    }
+
+    /**
      * Gets a rectangle representing the whole view area.
      * @return The rectangle.
      */
@@ -350 +360 @@
         public LatLon getLatLon() {
             return projection.eastNorth2latlon(getEastNorth());
         }
+
+        /**
+         * Add the given offset to this point
+         * @param en The offset in east/north space.
+         * @return The new point
+         */
+        public MapViewPoint add(EastNorth en) {
+            return new MapViewEastNorthPoint(getEastNorth().add(en));
+        }
     }
 
     private class MapViewViewPoint extends MapViewPoint {
@@ -454 +473 @@
         public Bounds getLatLonBoundsBox() {
             return projection.getLatLonBoundsBox(getProjectionBounds());
         }
+
+        /**
+         * Gets this rectangle on the screen.
+         * @return The rectangle.
+         */
+        public Rectangle2D getInView() {
+            double x1 = p1.getInViewX();
+            double y1 = p1.getInViewY();
+            double x2 = p2.getInViewX();
+            double y2 = p2.getInViewY();
+            return new Rectangle2D.Double(Math.min(x1, x2), Math.min(y1, y2), Math.abs(x1 - x2), Math.abs(y1 - y2));
+        }
     }
 
 }

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

@@ -12 +12 @@
 import java.awt.GridBagLayout;
 import java.awt.Image;
 import java.awt.Point;
-import java.awt.Rectangle;
 import java.awt.Toolkit;
 import java.awt.event.ActionEvent;
 import java.awt.event.MouseAdapter;
 import java.awt.event.MouseEvent;
+import java.awt.geom.Point2D;
+import java.awt.geom.Rectangle2D;
 import java.awt.image.BufferedImage;
 import java.awt.image.ImageObserver;
 import java.io.File;
@@ -36 +37 @@
 import java.util.Set;
 import java.util.concurrent.ConcurrentSkipListSet;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Stream;
 
 import javax.swing.AbstractAction;
 import javax.swing.Action;
@@ -67 +69 @@
 import org.openstreetmap.josm.actions.RenameLayerAction;
 import org.openstreetmap.josm.actions.SaveActionBase;
 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.LatLon;
 import org.openstreetmap.josm.data.imagery.ImageryInfo;
@@ -77 +80 @@
 import org.openstreetmap.josm.gui.ExtendedDialog;
 import org.openstreetmap.josm.gui.MapFrame;
 import org.openstreetmap.josm.gui.MapView;
+import org.openstreetmap.josm.gui.MapViewState.MapViewRectangle;
 import org.openstreetmap.josm.gui.NavigatableComponent.ZoomChangeListener;
 import org.openstreetmap.josm.gui.PleaseWaitRunnable;
 import org.openstreetmap.josm.gui.dialogs.LayerListDialog;
 import org.openstreetmap.josm.gui.dialogs.LayerListPopup;
 import org.openstreetmap.josm.gui.layer.imagery.ImageryFilterSettings.FilterChangeListener;
+import org.openstreetmap.josm.gui.layer.imagery.TileCoordinateConverter;
 import org.openstreetmap.josm.gui.layer.imagery.TileSourceDisplaySettings;
 import org.openstreetmap.josm.gui.layer.imagery.TileSourceDisplaySettings.DisplaySettingsChangeEvent;
 import org.openstreetmap.josm.gui.layer.imagery.TileSourceDisplaySettings.DisplaySettingsChangeListener;
@@ -169 +174 @@
     private final TileSourceDisplaySettings displaySettings = createDisplaySettings();
 
     private final ImageryAdjustAction adjustAction = new ImageryAdjustAction(this);
+    // prepared to be moved to the painter
+    private TileCoordinateConverter coordinateConverter;
 
     /**
      * Creates Tile Source based Imagery Layer based on Imagery Info
@@ -223 +230 @@
     }
 
     protected void initTileSource(T tileSource) {
+        coordinateConverter = new TileCoordinateConverter(Main.map.mapView, getDisplaySettings());
         attribution.initialize(tileSource);
 
         currentZoomLevel = getBestZoom();
@@ -420 +428 @@
             if (clickedTile != null) {
                 ExtendedDialog ed = new ExtendedDialog(Main.parent, tr("Tile Info"), new String[]{tr("OK")});
                 JPanel panel = new JPanel(new GridBagLayout());
-                Rectangle displaySize = tileToRect(clickedTile);
+                Rectangle2D displaySize = coordinateConverter.getRectangleForTile(clickedTile);
                 String url = "";
                 try {
                     url = clickedTile.getUrl();
@@ -433 +441 @@
                         {"Tile name", clickedTile.getKey()},
                         {"Tile url", url},
                         {"Tile size", getSizeString(clickedTile.getTileSource().getTileSize()) },
-                        {"Tile display size", new StringBuilder().append(displaySize.width).append('x').append(displaySize.height).toString()},
+                        {"Tile display size", new StringBuilder().append(displaySize.getWidth()).append('x').append(displaySize.getHeight()).toString()},
                 };
 
                 for (String[] entry: content) {
@@ -999 +1007 @@
 
     private TileSet getVisibleTileSet() {
         MapView mv = Main.map.mapView;
-        EastNorth topLeft = mv.getEastNorth(0, 0);
-        EastNorth botRight = mv.getEastNorth(mv.getWidth(), mv.getHeight());
-        return new MapWrappingTileSet(topLeft, botRight, currentZoomLevel);
+        MapViewRectangle area = mv.getState().getViewArea();
+        ProjectionBounds bounds = area.getProjectionBounds();
+        return getTileSet(bounds.getMin(), bounds.getMax(), currentZoomLevel);
     }
 
     protected void loadAllTiles(boolean force) {
@@ -1056 +1064 @@
         return img;
     }
 
-    private Rectangle tileToRect(Tile t1) {
-        /*
-         * We need to get a box in which to draw, so advance by one tile in
-         * each direction to find the other corner of the box.
-         * Note: this somewhat pollutes the tile cache
-         */
-        Tile t2 = tempCornerTile(t1);
-        Rectangle rect = new Rectangle(pixelPos(t1));
-        rect.add(pixelPos(t2));
-        return rect;
-    }
-
     // 'source' is the pixel coordinates for the area that
     // the img is capable of filling in.  However, we probably
     // only want a portion of it.
     //
     // 'border' is the screen cordinates that need to be drawn.
     //  We must not draw outside of it.
-    private void drawImageInside(Graphics g, Image sourceImg, Rectangle source, Rectangle border) {
-        Rectangle target = source;
+    private void drawImageInside(Graphics g, Image sourceImg, Rectangle2D source, Rectangle2D border) {
+        Rectangle2D target = source;
 
         // If a border is specified, only draw the intersection
         // if what we have combined with what we are supposed to draw.
         if (border != null) {
-            target = source.intersection(border);
+            target = source.createIntersection(border);
             if (Main.isDebugEnabled()) {
                 Main.debug("source: " + source + "\nborder: " + border + "\nintersection: " + target);
             }
@@ -1097 +1093 @@
         double imageXScaling = sourceImg.getWidth(this) / source.getWidth();
 
         // How many pixels into the 'source' rectangle are we drawing?
-        int screenXoffset = target.x - source.x;
-        int screenYoffset = target.y - source.y;
+        double screenXoffset = target.getX() - source.getX();
+        double screenYoffset = target.getY() - source.getY();
         // And how many pixels into the image itself does that correlate to?
         int imgXoffset = (int) (screenXoffset * imageXScaling + 0.5);
         int imgYoffset = (int) (screenYoffset * imageYScaling + 0.5);
@@ -1111 +1107 @@
             Main.debug("drawing image into target rect: " + target);
         }
         g.drawImage(sourceImg,
-                target.x, target.y,
-                target.x + target.width, target.y + target.height,
+                (int) target.getX(), (int) target.getY(),
+                (int) target.getMaxX(), (int) target.getMaxY(),
                 imgXoffset, imgYoffset,
                 imgXend, imgYend,
                 this);
         if (PROP_FADE_AMOUNT.get() != 0) {
             // dimm by painting opaque rect...
             g.setColor(getFadeColorWithAlpha());
-            g.fillRect(target.x, target.y,
-                    target.width, target.height);
+            ((Graphics2D)g).fill(target);
         }
     }
 
@@ -1135 +1130 @@
     // border is null and we draw the entire tile set.
     private List<Tile> paintTileImages(Graphics g, TileSet ts, int zoom, Tile border) {
         if (zoom <= 0) return Collections.emptyList();
-        Rectangle borderRect = null;
+        Rectangle2D borderRect = null;
         if (border != null) {
-            borderRect = tileToRect(border);
+            borderRect = coordinateConverter.getRectangleForTile(border);
         }
         List<Tile> missedTiles = new LinkedList<>();
         // The callers of this code *require* that we return any tiles
@@ -1157 +1152 @@
             // applying all filters to this layer
             img = applyImageProcessors((BufferedImage) img);
 
-            Rectangle sourceRect = tileToRect(tile);
+            Rectangle2D sourceRect = coordinateConverter.getRectangleForTile(tile);
             if (borderRect != null && !sourceRect.intersects(borderRect)) {
                 continue;
             }
@@ -1194 +1189 @@
     }
 
     private void paintTileText(TileSet ts, Tile tile, Graphics g, MapView mv, int zoom, Tile t) {
-        int fontHeight = g.getFontMetrics().getHeight();
-        if (tile == null)
+        if (tile == null) {
             return;
-        Point p = pixelPos(t);
-        int texty = p.y + 2 + fontHeight;
+        }
+        Point2D p = coordinateConverter.getPixelForTile(t);
+        int fontHeight = g.getFontMetrics().getHeight();
+        int x = (int) p.getX();
+        int y = (int) p.getY();
+        int texty = y + 2 + fontHeight;
 
         /*if (PROP_DRAW_DEBUG.get()) {
             myDrawString(g, "x=" + t.getXtile() + " y=" + t.getYtile() + " z=" + zoom + "", p.x + 2, texty);
@@ -1216 +1214 @@
         }*/
 
         if (tile.hasError() && getDisplaySettings().isShowErrors()) {
-            myDrawString(g, tr("Error") + ": " + tr(tile.getErrorMessage()), p.x + 2, texty);
+            myDrawString(g, tr("Error") + ": " + tr(tile.getErrorMessage()), x + 2, texty);
             //texty += 1 + fontHeight;
         }
 
@@ -1225 +1223 @@
         if (Main.isDebugEnabled()) {
             if (yCursor < t.getYtile()) {
                 if (t.getYtile() % 32 == 31) {
-                    g.fillRect(0, p.y - 1, mv.getWidth(), 3);
+                    g.fillRect(0, y - 1, mv.getWidth(), 3);
                 } else {
-                    g.drawLine(0, p.y, mv.getWidth(), p.y);
+                    g.drawLine(0, y, mv.getWidth(), y);
                 }
                 //yCursor = t.getYtile();
             }
@@ -1235 +1233 @@
             if (xCursor < t.getXtile()) {
                 if (t.getXtile() % 32 == 0) {
                     // level 7 tile boundary
-                    g.fillRect(p.x - 1, 0, 3, mv.getHeight());
+                    g.fillRect(x - 1, 0, 3, mv.getHeight());
                 } else {
-                    g.drawLine(p.x, 0, p.x, mv.getHeight());
+                    g.drawLine(x, 0, x, mv.getHeight());
                 }
                 //xCursor = t.getXtile();
             }
         }
     }
 
-    private Point pixelPos(LatLon ll) {
-        return Main.map.mapView.getPoint(Main.getProjection().latlon2eastNorth(ll).add(getDx(), getDy()));
-    }
-
-    private Point pixelPos(Tile t) {
-        ICoordinate coord = tileSource.tileXYToLatLon(t);
-        return pixelPos(new LatLon(coord));
-    }
-
     private LatLon getShiftedLatLon(EastNorth en) {
         return Main.getProjection().eastNorth2latlon(en.add(-getDx(), -getDy()));
     }
@@ -1268 +1257 @@
 
     private final TileSet nullTileSet = new TileSet();
 
-    private final class MapWrappingTileSet extends TileSet {
-        private MapWrappingTileSet(EastNorth topLeft, EastNorth botRight, int zoom) {
-            this(getShiftedLatLon(topLeft), getShiftedLatLon(botRight), zoom);
-        }
-
-        private MapWrappingTileSet(LatLon topLeft, LatLon botRight, int zoom) {
-            super(topLeft, botRight, zoom);
-            double centerLon = getShiftedLatLon(Main.map.mapView.getCenter()).lon();
+    /**
+     * This is a rectangular range of tiles.
+     */
+    private static class TileRange {
+        int minX, maxX, minY, maxY;
+        int zoom;
 
-            if (topLeft.lon() > centerLon) {
-                x0 = tileSource.getTileXMin(zoom);
-            }
-            if (botRight.lon() < centerLon) {
-                x1 = tileSource.getTileXMax(zoom);
-            }
-            sanitize();
+        private TileRange() {
         }
-    }
 
-    private class TileSet {
-        int x0, x1, y0, y1;
-        int zoom;
+        protected TileRange(TileXY t1, TileXY t2, int zoom) {
+            minX = (int) Math.floor(Math.min(t1.getX(), t2.getX()));
+            minY = (int) Math.floor(Math.min(t1.getY(), t2.getY()));
+            maxX = (int) Math.ceil(Math.max(t1.getX(), t2.getX()));
+            maxY = (int) Math.ceil(Math.max(t1.getY(), t2.getY()));
+            this.zoom = zoom;
+        }
 
-        /**
-         * Create a TileSet by EastNorth bbox taking a layer shift in account
-         * @param topLeft top-left lat/lon
-         * @param botRight bottom-right lat/lon
-         * @param zoom zoom level
-         */
-        protected TileSet(EastNorth topLeft, EastNorth botRight, int zoom) {
-            this(getShiftedLatLon(topLeft), getShiftedLatLon(botRight), zoom);
+        protected double tilesSpanned() {
+            return Math.sqrt(1.0 * this.size());
         }
 
-        /**
-         * Create a TileSet by known LatLon bbox without layer shift correction
-         * @param topLeft top-left lat/lon
-         * @param botRight bottom-right lat/lon
-         * @param zoom zoom level
-         */
-        protected TileSet(LatLon topLeft, LatLon botRight, int zoom) {
-            this.zoom = zoom;
-            if (zoom == 0)
-                return;
+        protected int size() {
+            int xSpan = maxX - minX + 1;
+            int ySpan = maxY - minY + 1;
+            return xSpan * ySpan;
+        }
+    }
 
-            TileXY t1 = tileSource.latLonToTileXY(topLeft.toCoordinate(), zoom);
-            TileXY t2 = tileSource.latLonToTileXY(botRight.toCoordinate(), zoom);
+    private class TileSet extends TileRange {
 
-            x0 = (int) Math.floor(t1.getX());
-            y0 = (int) Math.floor(t1.getY());
-            x1 = (int) Math.ceil(t2.getX());
-            y1 = (int) Math.ceil(t2.getY());
+        protected TileSet(TileXY t1, TileXY t2, int zoom) {
+            super(t1, t2, zoom);
             sanitize();
-
         }
 
         /**
@@ -1331 +1301 @@
         }
 
         protected void sanitize() {
-            if (x0 > x1) {
-                int tmp = x0;
-                x0 = x1;
-                x1 = tmp;
-            }
-            if (y0 > y1) {
-                int tmp = y0;
-                y0 = y1;
-                y1 = tmp;
+            if (minX < tileSource.getTileXMin(zoom)) {
+                minX = tileSource.getTileXMin(zoom);
             }
-
-            if (x0 < tileSource.getTileXMin(zoom)) {
-                x0 = tileSource.getTileXMin(zoom);
+            if (minY < tileSource.getTileYMin(zoom)) {
+                minY = tileSource.getTileYMin(zoom);
             }
-            if (y0 < tileSource.getTileYMin(zoom)) {
-                y0 = tileSource.getTileYMin(zoom);
+            if (maxX > tileSource.getTileXMax(zoom)) {
+                maxX = tileSource.getTileXMax(zoom);
             }
-            if (x1 > tileSource.getTileXMax(zoom)) {
-                x1 = tileSource.getTileXMax(zoom);
-            }
-            if (y1 > tileSource.getTileYMax(zoom)) {
-                y1 = tileSource.getTileYMax(zoom);
+            if (maxY > tileSource.getTileYMax(zoom)) {
+                maxY = tileSource.getTileYMax(zoom);
             }
         }
 
@@ -1368 +1327 @@
             return tileCache == null || size() > tileCache.getCacheSize();
         }
 
-        private double tilesSpanned() {
-            return Math.sqrt(1.0 * this.size());
-        }
-
-        private int size() {
-            int xSpan = x1 - x0 + 1;
-            int ySpan = y1 - y0 + 1;
-            return xSpan * ySpan;
-        }
-
         /*
          * Get all tiles represented by this TileSet that are
          * already in the tileCache.
@@ -1395 +1344 @@
             if (zoom == 0 || this.insane())
                 return Collections.emptyList();
             List<Tile> ret = new ArrayList<>();
-            for (int x = x0; x <= x1; x++) {
-                for (int y = y0; y <= y1; y++) {
+            for (int x = minX; x <= maxX; x++) {
+                for (int y = minY; y <= maxY; y++) {
                     Tile t;
                     if (create) {
                         t = getOrCreateTile(x, y, zoom);
@@ -1424 +1373 @@
          * @return comparator, that sorts the tiles from the center to the edge of the current screen
          */
         private Comparator<Tile> getTileDistanceComparator() {
-            final int centerX = (int) Math.ceil((x0 + x1) / 2d);
-            final int centerY = (int) Math.ceil((y0 + y1) / 2d);
+            final int centerX = (int) Math.ceil((minX + maxX) / 2d);
+            final int centerY = (int) Math.ceil((minY + maxY) / 2d);
             return new Comparator<Tile>() {
                 private int getDistance(Tile t) {
                     return Math.abs(t.getXtile() - centerX) + Math.abs(t.getYtile() - centerY);
@@ -1462 +1411 @@
 
         @Override
         public String toString() {
-            return getClass().getName() + ": zoom: " + zoom + " X(" + x0 + ", " + x1 + ") Y(" + y0 + ", " + y1 + ") size: " + size();
+            return getClass().getName() + ": zoom: " + zoom + " X(" + minX + ", " + maxX + ") Y(" + minY + ", " + maxY + ") size: " + size();
         }
     }
 
+    /**
+     * Create a TileSet by EastNorth bbox taking a layer shift in account
+     * @param topLeft top-left lat/lon
+     * @param botRight bottom-right lat/lon
+     * @param zoom zoom level
+     * @return the tile set
+     */
+    protected TileSet getTileSet(EastNorth topLeft, EastNorth botRight, int zoom) {
+        return getTileSet(getShiftedLatLon(topLeft), getShiftedLatLon(botRight), zoom);
+    }
+
+    /**
+     * Create a TileSet by known LatLon bbox without layer shift correction
+     * @param topLeft top-left lat/lon
+     * @param botRight bottom-right lat/lon
+     * @param zoom zoom level
+     * @return the tile set
+     */
+    protected TileSet getTileSet(LatLon topLeft, LatLon botRight, int zoom) {
+        if (zoom == 0)
+            return new TileSet();
+
+        TileXY t1 = tileSource.latLonToTileXY(topLeft.toCoordinate(), zoom);
+        TileXY t2 = tileSource.latLonToTileXY(botRight.toCoordinate(), zoom);
+        return new TileSet(t1, t2, zoom);
+    }
+
     private static class TileSetInfo {
         public boolean hasVisibleTiles;
         public boolean hasOverzoomedTiles;
@@ -1493 +1469 @@
     }
 
     private class DeepTileSet {
-        private final EastNorth topLeft, botRight;
+        private final ProjectionBounds bounds;
         private final int minZoom, maxZoom;
         private final TileSet[] tileSets;
         private final TileSetInfo[] tileSetInfos;
 
         @SuppressWarnings("unchecked")
-        DeepTileSet(EastNorth topLeft, EastNorth botRight, int minZoom, int maxZoom) {
-            this.topLeft = topLeft;
-            this.botRight = botRight;
+        DeepTileSet(ProjectionBounds bounds, int minZoom, int maxZoom) {
+            this.bounds = bounds;
             this.minZoom = minZoom;
             this.maxZoom = maxZoom;
             this.tileSets = new AbstractTileSourceLayer.TileSet[maxZoom - minZoom + 1];
@@ -1514 +1489 @@
             synchronized (tileSets) {
                 TileSet ts = tileSets[zoom-minZoom];
                 if (ts == null) {
-                    ts = new MapWrappingTileSet(topLeft, botRight, zoom);
+                    ts = AbstractTileSourceLayer.this.getTileSet(bounds.getMin(), bounds.getMax(), zoom);
                     tileSets[zoom-minZoom] = ts;
                 }
                 return ts;
@@ -1537 +1512 @@
 
     @Override
     public void paint(Graphics2D g, MapView mv, Bounds bounds) {
-        EastNorth topLeft = mv.getEastNorth(0, 0);
-        EastNorth botRight = mv.getEastNorth(mv.getWidth(), mv.getHeight());
-
-        if (botRight.east() == 0 || botRight.north() == 0) {
-            /*Main.debug("still initializing??");*/
-            // probably still initializing
-            return;
-        }
+        ProjectionBounds pb = mv.getState().getViewArea().getProjectionBounds();
 
         needRedraw = false;
 
@@ -1553 +1521 @@
             zoom = getBestZoom();
         }
 
-        DeepTileSet dts = new DeepTileSet(topLeft, botRight, getMinZoomLvl(), zoom);
+        DeepTileSet dts = new DeepTileSet(pb, getMinZoomLvl(), zoom);
         TileSet ts = dts.getTileSet(zoom);
 
         int displayZoomLevel = zoom;
@@ -1632 +1600 @@
                     continue;
                 }
                 Tile t2 = tempCornerTile(missed);
-                TileSet ts2 = new TileSet(
+                TileSet ts2 = getTileSet(
                         getShiftedLatLon(tileSource.tileXYToLatLon(missed)),
                         getShiftedLatLon(tileSource.tileXYToLatLon(t2)),
                         newzoom);
@@ -1660 +1628 @@
             this.paintTileText(ts, t, g, mv, displayZoomLevel, t);
         }
 
-        attribution.paintAttribution(g, mv.getWidth(), mv.getHeight(), getShiftedCoord(topLeft), getShiftedCoord(botRight),
+        EastNorth min = pb.getMin();
+        EastNorth max = pb.getMax();
+        attribution.paintAttribution(g, mv.getWidth(), mv.getHeight(), getShiftedCoord(min), getShiftedCoord(max),
                 displayZoomLevel, this);
 
         //g.drawString("currentZoomLevel=" + currentZoomLevel, 120, 120);
@@ -1710 +1680 @@
         EastNorth topLeft = mv.getEastNorth(0, 0);
         EastNorth botRight = mv.getEastNorth(mv.getWidth(), mv.getHeight());
         int z = currentZoomLevel;
-        TileSet ts = new TileSet(topLeft, botRight, z);
+        TileSet ts = getTileSet(topLeft, botRight, z);
 
         if (!ts.tooLarge()) {
             ts.loadAllTiles(false); // make sure there are tile objects for all tiles
         }
-        Tile clickedTile = null;
-        for (Tile t1 : ts.allExistingTiles()) {
-            Tile t2 = tempCornerTile(t1);
-            Rectangle r = new Rectangle(pixelPos(t1));
-            r.add(pixelPos(t2));
-            if (Main.isDebugEnabled()) {
-                Main.debug("r: " + r + " clicked: " + clicked);
-            }
-            if (!r.contains(clicked)) {
-                continue;
-            }
-            clickedTile = t1;
-            break;
-        }
-        if (clickedTile == null)
-            return null;
+        Stream<Tile> clickedTiles = ts.allExistingTiles().stream()
+                .filter(t -> coordinateConverter.getRectangleForTile(t).contains(clicked));
         if (Main.isTraceEnabled()) {
-            Main.trace("Clicked on tile: " + clickedTile.getXtile() + ' ' + clickedTile.getYtile() +
-                " currentZoomLevel: " + currentZoomLevel);
+            clickedTiles = clickedTiles.peek(t -> Main.trace("Clicked on tile: " + t.getXtile() + ' ' + t.getYtile() +
+                    " currentZoomLevel: " + currentZoomLevel));
         }
-        return clickedTile;
+        return clickedTiles.findAny().orElse(null);
     }
 
     @Override

new file src/org/openstreetmap/josm/gui/layer/imagery/TileCoordinateConverter.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.gui.layer.imagery;
+
+import java.awt.geom.Point2D;
+import java.awt.geom.Rectangle2D;
+
+import org.openstreetmap.gui.jmapviewer.Tile;
+import org.openstreetmap.gui.jmapviewer.interfaces.ICoordinate;
+import org.openstreetmap.josm.data.coor.LatLon;
+import org.openstreetmap.josm.gui.MapView;
+import org.openstreetmap.josm.gui.MapViewState.MapViewPoint;
+
+/**
+ * This class handles tile coordinate management and computes their position in the map view.
+ * @author Michael Zangl
+ * @since xxx
+ */
+public class TileCoordinateConverter {
+    private MapView mapView;
+    private TileSourceDisplaySettings settings;
+
+    /**
+     * Create a new coordinate converter for the map view.
+     * @param mapView The map view.
+     * @param settings displacement settings.
+     */
+    public TileCoordinateConverter(MapView mapView, TileSourceDisplaySettings settings) {
+        this.mapView = mapView;
+        this.settings = settings;
+    }
+
+    private MapViewPoint pos(ICoordinate ll) {
+        return mapView.getState().getPointFor(new LatLon(ll)).add(settings.getDisplacement());
+    }
+
+    /**
+     * Gets the top left position of the tile inside the map view.
+     * @param tile The tile
+     * @return The positon.
+     */
+    public Point2D getPixelForTile(Tile tile) {
+        ICoordinate coord = tile.getTileSource().tileXYToLatLon(tile);
+        return pos(coord).getInView();
+    }
+
+    /**
+     * Gets the position of the tile inside the map view.
+     * @param tile The tile
+     * @return The positon.
+     */
+    public Rectangle2D getRectangleForTile(Tile tile) {
+        ICoordinate c1 = tile.getTileSource().tileXYToLatLon(tile);
+        ICoordinate c2 = tile.getTileSource().tileXYToLatLon(tile.getXtile() + 1, tile.getYtile() + 1, tile.getZoom());
+
+        return pos(c1).rectTo(pos(c2)).getInView();
+    }
+}