allTiles = allTilesCreate();
- allTiles.sort(getTileDistanceComparator());
- for (Tile t : allTiles) {
- loadTile(t, force);
- }
- }
-
- private void loadAllErrorTiles(boolean force) {
- if (!getDisplaySettings().isAutoLoad() && !force)
- return;
- for (Tile t : this.allTilesCreate()) {
- if (t.hasError()) {
- tileLoader.createTileLoaderJob(t).submit(force);
- }
- }
- }
-
- /**
- * Call the given paint method for all tiles in this tile set.
- *
- * Uses a parallel stream.
- * @param visitor A visitor to call for each tile.
- * @param missed a consumer to call for each missed tile.
- */
- public void visitTiles(Consumer visitor, Consumer missed) {
- tilePositions().parallel().forEach(tp -> visitTilePosition(visitor, tp, missed));
- }
-
- private void visitTilePosition(Consumer visitor, TilePosition tp, Consumer missed) {
- Tile tile = getTile(tp);
- if (tile == null) {
- missed.accept(tp);
- } else {
- visitor.accept(tile);
- }
- }
-
- @Override
- public String toString() {
- 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
- * @since 10651
- */
- 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
- * @since 10651
- */
- 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;
- public boolean hasLoadingTiles;
- }
-
- private static TileSetInfo getTileSetInfo(AbstractTileSourceLayer.TileSet ts) {
- List allTiles = ts.allExistingTiles();
- TileSetInfo result = new TileSetInfo();
- result.hasLoadingTiles = allTiles.size() < ts.size();
- for (Tile t : allTiles) {
- if ("no-tile".equals(t.getValue("tile-info"))) {
- result.hasOverzoomedTiles = true;
- }
-
- if (t.isLoaded()) {
- if (!t.hasError()) {
- result.hasVisibleTiles = true;
- }
- } else if (t.isLoading()) {
- result.hasLoadingTiles = true;
- }
- }
- return result;
- }
-
- private class DeepTileSet {
- private final ProjectionBounds bounds;
- private final int minZoom, maxZoom;
- private final TileSet[] tileSets;
- private final TileSetInfo[] tileSetInfos;
-
- @SuppressWarnings("unchecked")
- DeepTileSet(ProjectionBounds bounds, int minZoom, int maxZoom) {
- this.bounds = bounds;
- this.minZoom = minZoom;
- this.maxZoom = maxZoom;
- this.tileSets = new AbstractTileSourceLayer.TileSet[maxZoom - minZoom + 1];
- this.tileSetInfos = new TileSetInfo[maxZoom - minZoom + 1];
- }
-
- public TileSet getTileSet(int zoom) {
- if (zoom < minZoom)
- return nullTileSet;
- synchronized (tileSets) {
- TileSet ts = tileSets[zoom-minZoom];
- if (ts == null) {
- ts = AbstractTileSourceLayer.this.getTileSet(bounds.getMin(), bounds.getMax(), zoom);
- tileSets[zoom-minZoom] = ts;
- }
- return ts;
- }
- }
-
- public TileSetInfo getTileSetInfo(int zoom) {
- if (zoom < minZoom)
- return new TileSetInfo();
- synchronized (tileSetInfos) {
- TileSetInfo tsi = tileSetInfos[zoom-minZoom];
- if (tsi == null) {
- tsi = AbstractTileSourceLayer.getTileSetInfo(getTileSet(zoom));
- tileSetInfos[zoom-minZoom] = tsi;
- }
- return tsi;
- }
- }
- }
-
- @Override
- public void paint(Graphics2D g, MapView mv, Bounds bounds) {
- // old and unused.
- }
-
- private void drawInViewArea(Graphics2D g, MapView mv, ProjectionBounds pb) {
- int zoom = currentZoomLevel;
- if (getDisplaySettings().isAutoZoom()) {
- zoom = getBestZoom();
- }
-
- DeepTileSet dts = new DeepTileSet(pb, getMinZoomLvl(), zoom);
- TileSet ts = dts.getTileSet(zoom);
-
- int displayZoomLevel = zoom;
-
- boolean noTilesAtZoom = false;
- if (getDisplaySettings().isAutoZoom() && getDisplaySettings().isAutoLoad()) {
- // Auto-detection of tilesource maxzoom (currently fully works only for Bing)
- TileSetInfo tsi = dts.getTileSetInfo(zoom);
- if (!tsi.hasVisibleTiles && (!tsi.hasLoadingTiles || tsi.hasOverzoomedTiles)) {
- noTilesAtZoom = true;
- }
- // Find highest zoom level with at least one visible tile
- for (int tmpZoom = zoom; tmpZoom > dts.minZoom; tmpZoom--) {
- if (dts.getTileSetInfo(tmpZoom).hasVisibleTiles) {
- displayZoomLevel = tmpZoom;
- break;
- }
- }
- // Do binary search between currentZoomLevel and displayZoomLevel
- while (zoom > displayZoomLevel && !tsi.hasVisibleTiles && tsi.hasOverzoomedTiles) {
- zoom = (zoom + displayZoomLevel)/2;
- tsi = dts.getTileSetInfo(zoom);
- }
-
- setZoomLevel(zoom);
-
- // If all tiles at displayZoomLevel is loaded, load all tiles at next zoom level
- // to make sure there're really no more zoom levels
- // loading is done in the next if section
- if (zoom == displayZoomLevel && !tsi.hasLoadingTiles && zoom < dts.maxZoom) {
- zoom++;
- tsi = dts.getTileSetInfo(zoom);
- }
- // When we have overzoomed tiles and all tiles at current zoomlevel is loaded,
- // load tiles at previovus zoomlevels until we have all tiles on screen is loaded.
- // loading is done in the next if section
- while (zoom > dts.minZoom && tsi.hasOverzoomedTiles && !tsi.hasLoadingTiles) {
- zoom--;
- tsi = dts.getTileSetInfo(zoom);
- }
- ts = dts.getTileSet(zoom);
- } else if (getDisplaySettings().isAutoZoom()) {
- setZoomLevel(zoom);
- }
-
- // Too many tiles... refuse to download
- if (!ts.tooLarge()) {
- //Main.debug("size: " + ts.size() + " spanned: " + ts.tilesSpanned());
- ts.loadAllTiles(false);
- }
-
- if (displayZoomLevel != zoom) {
- ts = dts.getTileSet(displayZoomLevel);
- }
-
- g.setColor(Color.DARK_GRAY);
-
- List missedTiles = this.paintTileImages(g, ts);
- int[] otherZooms = {-1, 1, -2, 2, -3, -4, -5};
- for (int zoomOffset : otherZooms) {
- if (!getDisplaySettings().isAutoZoom()) {
- break;
- }
- int newzoom = displayZoomLevel + zoomOffset;
- if (newzoom < getMinZoomLvl() || newzoom > getMaxZoomLvl()) {
- continue;
- }
- if (missedTiles.isEmpty()) {
- break;
- }
- List newlyMissedTiles = new LinkedList<>();
- for (Tile missed : missedTiles) {
- if ("no-tile".equals(missed.getValue("tile-info")) && zoomOffset > 0) {
- // Don't try to paint from higher zoom levels when tile is overzoomed
- newlyMissedTiles.add(missed);
- continue;
- }
- Tile t2 = tempCornerTile(missed);
- TileSet ts2 = getTileSet(
- getShiftedLatLon(tileSource.tileXYToLatLon(missed)),
- getShiftedLatLon(tileSource.tileXYToLatLon(t2)),
- newzoom);
- // Instantiating large TileSets is expensive. If there
- // are no loaded tiles, don't bother even trying.
- if (ts2.allLoadedTiles().isEmpty()) {
- newlyMissedTiles.add(missed);
- continue;
- }
- if (ts2.tooLarge()) {
- continue;
- }
- newlyMissedTiles.addAll(this.paintTileImages(g, ts2, newzoom, missed));
- }
- missedTiles = newlyMissedTiles;
- }
- if (Main.isDebugEnabled() && !missedTiles.isEmpty()) {
- Main.debug("still missed "+missedTiles.size()+" in the end");
- }
- g.setColor(Color.red);
- g.setFont(InfoFont);
-
- // 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(ts, t, g, mv, displayZoomLevel, t);
- }
-
- 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);
- g.setColor(Color.lightGray);
-
- if (ts.insane()) {
- myDrawString(g, tr("zoom in to load any tiles"), 120, 120);
- } else if (ts.tooLarge()) {
- myDrawString(g, tr("zoom in to load more tiles"), 120, 120);
- } else if (!getDisplaySettings().isAutoZoom() && ts.tooSmall()) {
- myDrawString(g, tr("increase tiles zoom level (change resolution) to see more detail"), 120, 120);
- }
-
- if (noTilesAtZoom) {
- myDrawString(g, tr("No tiles at this zoom level"), 120, 120);
- }
- if (Main.isDebugEnabled()) {
- myDrawString(g, tr("Current zoom: {0}", currentZoomLevel), 50, 140);
- myDrawString(g, tr("Display zoom: {0}", displayZoomLevel), 50, 155);
- myDrawString(g, tr("Pixel scale: {0}", getScaleFactor(currentZoomLevel)), 50, 170);
- myDrawString(g, tr("Best zoom: {0}", getBestZoom()), 50, 185);
- myDrawString(g, tr("Estimated cache size: {0}", estimateTileCacheSize()), 50, 200);
- if (tileLoader instanceof TMSCachedTileLoader) {
- TMSCachedTileLoader cachedTileLoader = (TMSCachedTileLoader) tileLoader;
- int offset = 200;
- for (String part: cachedTileLoader.getStats().split("\n")) {
- offset += 15;
- myDrawString(g, tr("Cache stats: {0}", part), 50, offset);
- }
- }
- }
- }
-
- /**
- * Returns tile for a pixel position.
- * This isn't very efficient, but it is only used when the user right-clicks on the map.
- * @param px pixel X coordinate
- * @param py pixel Y coordinate
- * @return Tile at pixel position
- */
- private Tile getTileForPixelpos(int px, int py) {
- if (Main.isDebugEnabled()) {
- Main.debug("getTileForPixelpos("+px+", "+py+')');
- }
- MapView mv = Main.map.mapView;
- Point clicked = new Point(px, py);
- EastNorth topLeft = mv.getEastNorth(0, 0);
- EastNorth botRight = mv.getEastNorth(mv.getWidth(), mv.getHeight());
- int z = currentZoomLevel;
- TileSet ts = getTileSet(topLeft, botRight, z);
-
- if (!ts.tooLarge()) {
- ts.loadAllTiles(false); // make sure there are tile objects for all tiles
- }
- Stream 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);
- }
-
@Override
public Action[] getMenuEntries() {
ArrayList actions = new ArrayList<>();
@@ -1803,16 +537,12 @@ implements ImageObserver, TileLoaderListener, ZoomChangeListener, FilterChangeLi
}
public Action[] getLayerListEntries() {
- return new Action[] {
- LayerListDialog.getInstance().createActivateLayerAction(this),
- LayerListDialog.getInstance().createShowHideLayerAction(),
- LayerListDialog.getInstance().createDeleteLayerAction(),
- SeparatorLayerAction.INSTANCE,
- // color,
- new OffsetAction(),
- new RenameLayerAction(this.getAssociatedFile(), this),
- SeparatorLayerAction.INSTANCE
- };
+ return new Action[] { LayerListDialog.getInstance().createActivateLayerAction(this),
+ LayerListDialog.getInstance().createShowHideLayerAction(),
+ LayerListDialog.getInstance().createDeleteLayerAction(), SeparatorLayerAction.INSTANCE,
+ // color,
+ new OffsetAction(), new RenameLayerAction(this.getAssociatedFile(), this),
+ SeparatorLayerAction.INSTANCE };
}
/**
@@ -1821,25 +551,25 @@ implements ImageObserver, TileLoaderListener, ZoomChangeListener, FilterChangeLi
*/
public Action[] getCommonEntries() {
return new Action[] {
- new AutoLoadTilesAction(),
- new AutoZoomAction(),
- new ShowErrorsAction(),
- new IncreaseZoomAction(),
- new DecreaseZoomAction(),
- new ZoomToBestAction(),
- new ZoomToNativeLevelAction(),
- new FlushTileCacheAction(),
- new LoadErroneusTilesAction(),
- new LoadAllTilesAction()
- };
+ new AutoLoadTilesAction(),
+ new AutoZoomAction(),
+ new ShowErrorsAction() };
+ }
+
+ private List getMapViewEntries(MapView mv) {
+ TileSourcePainter painter = painters.get(mv);
+ return painter.getMenuEntries();
}
@Override
public String getToolTipText() {
+ String currentZoomLevel = painters.values().stream().findAny().map(TileSourcePainter::getZoomString).orElse("?");
if (getDisplaySettings().isAutoLoad()) {
- return tr("{0} ({1}), automatically downloading in zoom {2}", this.getClass().getSimpleName(), getName(), currentZoomLevel);
+ return tr("{0} ({1}), automatically downloading in zoom {2}", this.getClass().getSimpleName(), getName(),
+ currentZoomLevel);
} else {
- return tr("{0} ({1}), downloading in zoom {2}", this.getClass().getSimpleName(), getName(), currentZoomLevel);
+ return tr("{0} ({1}), downloading in zoom {2}", this.getClass().getSimpleName(), getName(),
+ currentZoomLevel);
}
}
@@ -1853,6 +583,12 @@ implements ImageObserver, TileLoaderListener, ZoomChangeListener, FilterChangeLi
return false;
}
+ @Override
+ public void paint(Graphics2D g, MapView mv, Bounds bbox) {
+ // never called, we use a custom painter
+ throw new UnsupportedOperationException();
+ }
+
/**
* Task responsible for precaching imagery along the gpx track
*
@@ -1868,10 +604,12 @@ implements ImageObserver, TileLoaderListener, ZoomChangeListener, FilterChangeLi
*/
public PrecacheTask(ProgressMonitor progressMonitor) {
this.progressMonitor = progressMonitor;
+ // TODO
+ T tileSource = null;
this.tileLoader = getTileLoaderFactory().makeTileLoader(this, getHeaders(tileSource));
if (this.tileLoader instanceof TMSCachedTileLoader) {
- ((TMSCachedTileLoader) this.tileLoader).setDownloadExecutor(
- TMSCachedTileLoader.getNewThreadPoolExecutor("Precache downloader"));
+ ((TMSCachedTileLoader) this.tileLoader)
+ .setDownloadExecutor(TMSCachedTileLoader.getNewThreadPoolExecutor("Precache downloader"));
}
}
@@ -1929,13 +667,15 @@ implements ImageObserver, TileLoaderListener, ZoomChangeListener, FilterChangeLi
* @param bufferY how many units in current Coordinate Reference System to cover in Y axis in both sides
* @return precache task representing download task
*/
- public AbstractTileSourceLayer.PrecacheTask downloadAreaToCache(final ProgressMonitor progressMonitor, List points,
- double bufferX, double bufferY) {
+ public AbstractTileSourceLayer.PrecacheTask downloadAreaToCache(final ProgressMonitor progressMonitor,
+ List points, double bufferX, double bufferY) {
PrecacheTask precacheTask = new PrecacheTask(progressMonitor);
final Set requestedTiles = new ConcurrentSkipListSet<>(
(o1, o2) -> String.CASE_INSENSITIVE_ORDER.compare(o1.getKey(), o2.getKey()));
- for (LatLon point: points) {
-
+ for (LatLon point : points) {
+ //TODO
+ TileSource tileSource = null;
+ int currentZoomLevel = 0;
TileXY minTile = tileSource.latLonToTileXY(point.lat() - bufferY, point.lon() - bufferX, currentZoomLevel);
TileXY curTile = tileSource.latLonToTileXY(point.toCoordinate(), currentZoomLevel);
TileXY maxTile = tileSource.latLonToTileXY(point.lat() + bufferY, point.lon() + bufferX, currentZoomLevel);
@@ -1957,7 +697,7 @@ implements ImageObserver, TileLoaderListener, ZoomChangeListener, FilterChangeLi
precacheTask.progressMonitor.setTicksCount(requestedTiles.size());
TileLoader loader = precacheTask.getTileLoader();
- for (Tile t: requestedTiles) {
+ for (Tile t : requestedTiles) {
loader.createTileLoaderJob(t).submit();
}
return precacheTask;
@@ -1979,51 +719,12 @@ implements ImageObserver, TileLoaderListener, ZoomChangeListener, FilterChangeLi
adjustAction.destroy();
}
- private class TileSourcePainter extends CompatibilityModeLayerPainter {
- /**
- * The memory handle that will hold our tile source.
- */
- private MemoryHandle memory;
-
- @Override
- public void paint(MapViewGraphics graphics) {
- allocateCacheMemory();
- if (memory != null) {
- doPaint(graphics);
- }
- }
-
- private void doPaint(MapViewGraphics graphics) {
- ProjectionBounds pb = graphics.getClipBounds().getProjectionBounds();
-
- drawInViewArea(graphics.getDefaultGraphics(), graphics.getMapView(), pb);
- }
-
- private void allocateCacheMemory() {
- if (memory == null) {
- MemoryManager manager = MemoryManager.getInstance();
- if (manager.isAvailable(getEstimatedCacheSize())) {
- try {
- memory = manager.allocateMemory("tile source layer", getEstimatedCacheSize(), Object::new);
- } catch (NotEnoughMemoryException e) {
- Main.warn("Could not allocate tile source memory", e);
- }
- }
- }
- }
-
- protected long getEstimatedCacheSize() {
- return 4L * tileSource.getTileSize() * tileSource.getTileSize() * estimateTileCacheSize();
- }
-
- @Override
- public void detachFromMapView(MapViewEvent event) {
- event.getMapView().removeMouseListener(adapter);
- MapView.removeZoomChangeListener(AbstractTileSourceLayer.this);
- super.detachFromMapView(event);
- if (memory != null) {
- memory.free();
- }
- }
+ /**
+ * A {@link TileSourcePainter} notifies us of a dispatch
+ * @param tileSourcePainter The painter.
+ */
+ public void detach(TileSourcePainter tileSourcePainter) {
+ GuiHelper.assertCallFromEdt();
+ painters.entrySet().removeIf(e -> e.getValue().equals(tileSourcePainter));
}
}
diff --git a/src/org/openstreetmap/josm/gui/layer/TMSLayer.java b/src/org/openstreetmap/josm/gui/layer/TMSLayer.java
index bf833ff..e220828 100644
--- a/src/org/openstreetmap/josm/gui/layer/TMSLayer.java
+++ b/src/org/openstreetmap/josm/gui/layer/TMSLayer.java
@@ -22,6 +22,8 @@ import org.openstreetmap.josm.data.imagery.TMSCachedTileLoader;
import org.openstreetmap.josm.data.preferences.BooleanProperty;
import org.openstreetmap.josm.data.preferences.IntegerProperty;
import org.openstreetmap.josm.data.projection.Projection;
+import org.openstreetmap.josm.gui.layer.NativeScaleLayer.ScaleList;
+import org.openstreetmap.josm.gui.layer.imagery.TileSourcePainter;
/**
* Class that displays a slippy map layer.
@@ -32,7 +34,7 @@ import org.openstreetmap.josm.data.projection.Projection;
* @author Upliner <upliner@gmail.com>
* @since 3715
*/
-public class TMSLayer extends AbstractCachedTileSourceLayer implements NativeScaleLayer {
+public class TMSLayer extends AbstractCachedTileSourceLayer {
private static final String CACHE_REGION_NAME = "TMS";
private static final String PREFERENCE_PREFIX = "imagery.tms";
@@ -57,32 +59,6 @@ public class TMSLayer extends AbstractCachedTileSourceLayer imple
super(info);
}
- /**
- * Creates and returns a new TileSource instance depending on the {@link ImageryType}
- * of the passed ImageryInfo object.
- *
- * If no appropriate TileSource is found, null is returned.
- * Currently supported ImageryType are {@link ImageryType#TMS},
- * {@link ImageryType#BING}, {@link ImageryType#SCANEX}.
- *
- *
- * @param info imagery info
- * @return a new TileSource instance or null if no TileSource for the ImageryInfo/ImageryType could be found.
- * @throws IllegalArgumentException if url from imagery info is null or invalid
- */
- @Override
- protected TMSTileSource getTileSource(ImageryInfo info) {
- return getTileSourceStatic(info, () -> {
- Main.debug("Attribution loaded, running loadAllErrorTiles");
- this.loadAllErrorTiles(false);
- });
- }
-
- @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");
@@ -148,10 +124,6 @@ public class TMSLayer extends AbstractCachedTileSourceLayer imple
return AbstractCachedTileSourceLayer.getCache(CACHE_REGION_NAME);
}
- @Override
- public ScaleList getNativeScales() {
- return nativeScaleList;
- }
private static ScaleList initNativeScaleList() {
Collection scales = new ArrayList<>(AbstractTileSourceLayer.MAX_ZOOM);
@@ -161,4 +133,26 @@ public class TMSLayer extends AbstractCachedTileSourceLayer imple
}
return new ScaleList(scales);
}
+
+ @Override
+ protected TileSourcePainter createMapViewPainter(MapViewEvent event) {
+ return new TileSourcePainter(this, event.getMapView()) {
+ @Override
+ public final boolean isProjectionSupported(Projection proj) {
+ return "EPSG:3857".equals(proj.toCode()) || "EPSG:4326".equals(proj.toCode());
+ }
+ // TODO @Override
+// public ScaleList getNativeScales() {
+// return nativeScaleList;
+// }
+
+ @Override
+ protected TMSTileSource generateTileSource(AbstractTileSourceLayer layer) {
+ return getTileSourceStatic(info, () -> {
+ Main.debug("Attribution loaded, running loadAllErrorTiles");
+ loadAllErrorTiles(false);
+ });
+ }
+ };
+ }
}
diff --git a/src/org/openstreetmap/josm/gui/layer/WMSLayer.java b/src/org/openstreetmap/josm/gui/layer/WMSLayer.java
index acf27c6..5c8fbf2 100644
--- a/src/org/openstreetmap/josm/gui/layer/WMSLayer.java
+++ b/src/org/openstreetmap/josm/gui/layer/WMSLayer.java
@@ -6,6 +6,7 @@ import static org.openstreetmap.josm.tools.I18n.tr;
import java.awt.event.ActionEvent;
import java.util.ArrayList;
import java.util.Arrays;
+import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
@@ -13,7 +14,6 @@ import java.util.TreeSet;
import javax.swing.AbstractAction;
import javax.swing.Action;
-import javax.swing.JOptionPane;
import org.apache.commons.jcs.access.CacheAccess;
import org.openstreetmap.gui.jmapviewer.interfaces.TileLoader;
@@ -27,8 +27,10 @@ import org.openstreetmap.josm.data.imagery.WMSCachedTileLoader;
import org.openstreetmap.josm.data.preferences.BooleanProperty;
import org.openstreetmap.josm.data.preferences.IntegerProperty;
import org.openstreetmap.josm.data.projection.Projection;
-import org.openstreetmap.josm.gui.ExtendedDialog;
+import org.openstreetmap.josm.data.projection.ProjectionChangeListener;
+import org.openstreetmap.josm.gui.MapView;
import org.openstreetmap.josm.gui.layer.imagery.TileSourceDisplaySettings;
+import org.openstreetmap.josm.gui.layer.imagery.TileSourcePainter;
/**
* This is a layer that grabs the current screen from an WMS server. The data
@@ -115,13 +117,6 @@ public class WMSLayer extends AbstractCachedTileSourceLayer" + tr("The layer {0} does not support the new projection {1}.", getName(), newValue.toCode()) +
- "
" +
- tr("Supported projections are: {0}", nameSupportedProjections()) + "
" +
- "" + 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());
- }
- warningDialog.showDialog();
- }
-
- if (!newValue.equals(oldValue)) {
- tileSource.initProjection(newValue);
- }
- }
+// @Override
+// public void projectionChanged(Projection oldValue, Projection newValue) {
+// // do not call super - we need custom warning dialog
+//
+// if (!isProjectionSupported(newValue)) {
+// String message =
+// "
" + tr("The layer {0} does not support the new projection {1}.", getName(), newValue.toCode()) +
+// "
" +
+// tr("Supported projections are: {0}", nameSupportedProjections()) + "
" +
+// "" + 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()) {
+//// TODO: warningDialog.toggleEnable("imagery.wms.projectionSupportWarnings." + tileSource.getBaseUrl());
+// }
+// warningDialog.showDialog();
+// }
+// }
@Override
protected Class getTileLoaderClass() {
@@ -182,4 +173,40 @@ public class WMSLayer extends AbstractCachedTileSourceLayer createMapViewPainter(MapViewEvent event) {
+ return new WMSPainter(this, event.getMapView());
+ }
+
+ private static class WMSPainter extends TileSourcePainter {
+ private final ProjectionChangeListener initOnProjectionChange = (oldValue, newValue) -> tileSource.initProjection(newValue);
+ private HashSet supportedProjections;
+
+ public WMSPainter(AbstractTileSourceLayer abstractTileSourceLayer, MapView mapView) {
+ super(abstractTileSourceLayer, mapView);
+ Main.addProjectionChangeListener(initOnProjectionChange);
+
+ ImageryInfo info2 = abstractTileSourceLayer.getInfo();
+ supportedProjections = new HashSet<>(info2.getServerProjections());
+ if (info2.isEpsg4326To3857Supported() && supportedProjections.contains("EPSG:4326")) {
+ supportedProjections.add("EPSG:3857");
+ }
+
+ zoom.setZoomBounds(0, zoom.getMaxZoom());
+ }
+
+ @Override
+ public void detachFromMapView(MapViewEvent event) {
+ Main.removeProjectionChangeListener(initOnProjectionChange);
+ super.detachFromMapView(event);
+ }
+
+ @Override
+ public boolean isProjectionSupported(Projection proj) {
+ return supportedProjections == null || supportedProjections.isEmpty() || supportedProjections.contains(proj.toCode());
+
+ }
+
+ }
}
diff --git a/src/org/openstreetmap/josm/gui/layer/WMTSLayer.java b/src/org/openstreetmap/josm/gui/layer/WMTSLayer.java
index f4cb70c..07ac173 100644
--- a/src/org/openstreetmap/josm/gui/layer/WMTSLayer.java
+++ b/src/org/openstreetmap/josm/gui/layer/WMTSLayer.java
@@ -2,7 +2,6 @@
package org.openstreetmap.josm.gui.layer;
import java.io.IOException;
-import java.util.Set;
import org.apache.commons.jcs.access.CacheAccess;
import org.openstreetmap.gui.jmapviewer.interfaces.TileLoader;
@@ -13,7 +12,10 @@ import org.openstreetmap.josm.data.imagery.ImageryInfo.ImageryType;
import org.openstreetmap.josm.data.imagery.WMSCachedTileLoader;
import org.openstreetmap.josm.data.imagery.WMTSTileSource;
import org.openstreetmap.josm.data.projection.Projection;
+import org.openstreetmap.josm.data.projection.ProjectionChangeListener;
+import org.openstreetmap.josm.gui.MapView;
import org.openstreetmap.josm.gui.layer.imagery.TileSourceDisplaySettings;
+import org.openstreetmap.josm.gui.layer.imagery.TileSourcePainter;
/**
* WMTS layer based on AbstractTileSourceLayer. Overrides few methods to align WMTS to Tile based computations
@@ -25,7 +27,7 @@ import org.openstreetmap.josm.gui.layer.imagery.TileSourceDisplaySettings;
* @author Wiktor Niesiobędzki
*
*/
-public class WMTSLayer extends AbstractCachedTileSourceLayer implements NativeScaleLayer {
+public class WMTSLayer extends AbstractCachedTileSourceLayer {
private static final String PREFERENCE_PREFIX = "imagery.wmts";
/**
@@ -50,65 +52,33 @@ public class WMTSLayer extends AbstractCachedTileSourceLayer imp
return new TileSourceDisplaySettings(PREFERENCE_PREFIX);
}
- @Override
- protected WMTSTileSource getTileSource(ImageryInfo info) {
- try {
- if (info.getImageryType() == ImageryType.WMTS && info.getUrl() != null) {
- WMTSTileSource.checkUrl(info.getUrl());
- WMTSTileSource tileSource = new WMTSTileSource(info);
- info.setAttribution(tileSource);
- return tileSource;
- }
- return null;
- } catch (IOException e) {
- Main.warn(e);
- throw new IllegalArgumentException(e);
- }
- }
-
- @Override
- protected int getBestZoom() {
- if (!Main.isDisplayingMapView())
- return 0;
- ScaleList scaleList = getNativeScales();
- if (scaleList == null) {
- return getMaxZoomLvl();
- }
- Scale snap = scaleList.getSnapScale(Main.map.mapView.getScale(), false);
- return Math.max(
- getMinZoomLvl(),
- Math.min(
- snap != null ? snap.getIndex() : getMaxZoomLvl(),
- getMaxZoomLvl()
- )
- );
- }
-
- @Override
- protected int getMinZoomLvl() {
- return 0;
- }
-
- @Override
- public boolean isProjectionSupported(Projection proj) {
- Set 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();
- }
-
- @Override
- public void projectionChanged(Projection oldValue, Projection newValue) {
- super.projectionChanged(oldValue, newValue);
- tileSource.initProjection(newValue);
- }
+ // TODO @Override
+ // protected int getBestZoom() {
+ // if (!Main.isDisplayingMapView())
+ // return 0;
+ // ScaleList scaleList = getNativeScales();
+ // if (scaleList == null) {
+ // return getMaxZoomLvl();
+ // }
+ // Scale snap = scaleList.getSnapScale(Main.map.mapView.getScale(), false);
+ // return Math.max(
+ // getMinZoomLvl(),
+ // Math.min(
+ // snap != null ? snap.getIndex() : getMaxZoomLvl(),
+ // getMaxZoomLvl()
+ // )
+ // );
+ // }
+
+ //
+ // @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();
+ // }
@Override
protected Class getTileLoaderClass() {
@@ -127,8 +97,53 @@ public class WMTSLayer extends AbstractCachedTileSourceLayer imp
return AbstractCachedTileSourceLayer.getCache(CACHE_REGION_NAME);
}
+ // TODO @Override
+ // public ScaleList getNativeScales() {
+ // return tileSource.getNativeScales();
+ // }
+
@Override
- public ScaleList getNativeScales() {
- return tileSource.getNativeScales();
+ protected TileSourcePainter createMapViewPainter(MapViewEvent event) {
+ return new WMTSPainter(this, event.getMapView());
+ }
+
+ private static class WMTSPainter extends TileSourcePainter {
+ private final ProjectionChangeListener initOnProjectionChange = (oldValue, newValue) -> tileSource
+ .initProjection(newValue);
+
+ public WMTSPainter(AbstractTileSourceLayer abstractTileSourceLayer, MapView mapView) {
+ super(abstractTileSourceLayer, mapView);
+ Main.addProjectionChangeListener(initOnProjectionChange);
+
+ zoom.setZoomBounds(0, zoom.getMaxZoom());
+ }
+
+ @Override
+ protected WMTSTileSource generateTileSource(AbstractTileSourceLayer layer) {
+ try {
+ ImageryInfo layerInfo = layer.getInfo();
+ if (layerInfo.getImageryType() == ImageryType.WMTS && layerInfo.getUrl() != null) {
+ WMTSTileSource.checkUrl(layerInfo.getUrl());
+ WMTSTileSource tileSource = new WMTSTileSource(layerInfo);
+ layerInfo.setAttribution(tileSource);
+ return tileSource;
+ }
+ return null;
+ } catch (IOException e) {
+ Main.warn(e);
+ throw new IllegalArgumentException(e);
+ }
+ }
+
+ @Override
+ public void detachFromMapView(MapViewEvent event) {
+ Main.removeProjectionChangeListener(initOnProjectionChange);
+ super.detachFromMapView(event);
+ }
+
+ @Override
+ public boolean isProjectionSupported(Projection proj) {
+ return tileSource.getSupportedProjections().contains(proj.toCode());
+ }
}
}
diff --git a/src/org/openstreetmap/josm/gui/layer/imagery/AbstractTileSourceLoader.java b/src/org/openstreetmap/josm/gui/layer/imagery/AbstractTileSourceLoader.java
new file mode 100644
index 0000000..248cded
--- /dev/null
+++ b/src/org/openstreetmap/josm/gui/layer/imagery/AbstractTileSourceLoader.java
@@ -0,0 +1,286 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.gui.layer.imagery;
+
+import static org.openstreetmap.josm.tools.I18n.tr;
+
+import java.awt.Dimension;
+import java.awt.event.ActionEvent;
+import java.util.function.Predicate;
+
+import javax.swing.AbstractAction;
+
+import org.openstreetmap.gui.jmapviewer.AttributionSupport;
+import org.openstreetmap.gui.jmapviewer.MemoryTileCache;
+import org.openstreetmap.gui.jmapviewer.Tile;
+import org.openstreetmap.gui.jmapviewer.interfaces.CachedTileLoader;
+import org.openstreetmap.gui.jmapviewer.interfaces.TileCache;
+import org.openstreetmap.gui.jmapviewer.interfaces.TileLoader;
+import org.openstreetmap.gui.jmapviewer.tilesources.AbstractTMSTileSource;
+import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.data.imagery.TMSCachedTileLoader;
+import org.openstreetmap.josm.gui.MapView;
+import org.openstreetmap.josm.gui.NavigatableComponent.ZoomChangeListener;
+import org.openstreetmap.josm.gui.PleaseWaitRunnable;
+import org.openstreetmap.josm.gui.layer.AbstractTileSourceLayer;
+import org.openstreetmap.josm.gui.layer.imagery.TileForAreaFinder.TileForAreaGetter;
+import org.openstreetmap.josm.gui.util.GuiHelper;
+import org.openstreetmap.josm.tools.MemoryManager;
+import org.openstreetmap.josm.tools.MemoryManager.MemoryHandle;
+import org.openstreetmap.josm.tools.MemoryManager.NotEnoughMemoryException;
+
+/**
+ * This class backs the {@link TileSourcePainter} by handling the loading / acces of the tile images
+ * @author Michael Zangl
+ * @param The imagery type to use
+ * @since xxx
+ */
+public abstract class AbstractTileSourceLoader implements TileForAreaGetter, ZoomChangeListener {
+
+ /*
+ * use MemoryTileCache instead of tileLoader JCS cache, as tileLoader caches only content (byte[] of image)
+ * and MemoryTileCache caches whole Tile. This gives huge performance improvement when a lot of tiles are visible
+ * in MapView (for example - when limiting min zoom in imagery)
+ *
+ * Use per-layer tileCache instance, as the more layers there are, the more tiles needs to be cached
+ */
+ private final TileCache tileCache; // initialized together with tileSource
+ protected final T tileSource;
+ protected final TileLoader tileLoader;
+ protected final AttributionSupport attribution = new AttributionSupport();
+
+ /**
+ * The memory handle that will hold our tile source.
+ */
+ private MemoryHandle memory;
+
+ protected AbstractTileSourceLoader(AbstractTileSourceLayer layer) {
+ tileSource = generateTileSource(layer);
+ if (tileSource == null) {
+ throw new IllegalArgumentException(tr("Failed to create tile source"));
+ }
+
+ attribution.initialize(tileSource);
+
+ tileLoader = layer.generateTileLoader(tileSource);
+
+ tileCache = new MemoryTileCache(estimateTileCacheSize());
+ MapView.addZoomChangeListener(this);
+ }
+
+ protected T generateTileSource(AbstractTileSourceLayer layer) {
+ return layer.getTileSource();
+ }
+ /**
+ * Check if there are any matching tiles in the given range
+ * @param range The range to check in
+ * @param pred The predicate the tiles need to match
+ * @return If there are such tiles.
+ */
+ public boolean hasTiles(TileRange range, Predicate pred) {
+ return range.tilePositions().map(this::getTile).anyMatch(pred);
+ }
+
+ protected Tile getOrCreateTile(TilePosition tilePosition) {
+ Tile tile = getTile(tilePosition);
+ if (tile == null) {
+ tile = new Tile(tileSource, tilePosition.getX(), tilePosition.getY(), tilePosition.getZoom());
+ tileCache.addTile(tile);
+ }
+
+ if (!tile.isLoaded()) {
+ tile.loadPlaceholderFromCache(tileCache);
+ }
+ return tile;
+ }
+
+ /**
+ * Returns tile at given position.
+ * This can and will return null for tiles that are not already in the cache.
+ * @param tilePosition The position
+ * @return tile at given position
+ */
+ protected Tile getTile(TilePosition tilePosition) {
+ if (!contains(tilePosition)) {
+ return null;
+ } else {
+ return tileCache.getTile(tileSource, tilePosition.getX(), tilePosition.getY(), tilePosition.getZoom());
+ }
+ }
+
+ /**
+ * Check if this tile source contains the given position.
+ * @param position The position
+ * @return true if that positon is contained.
+ */
+ private boolean contains(TilePosition position) {
+ return position.getZoom() >= tileSource.getMinZoom() && position.getZoom() <= tileSource.getMaxZoom()
+ && position.getX() >= tileSource.getTileXMin(position.getZoom())
+ && position.getX() <= tileSource.getTileXMax(position.getZoom())
+ && position.getY() >= tileSource.getTileYMin(position.getZoom())
+ && position.getY() <= tileSource.getTileYMax(position.getZoom());
+ }
+
+ protected void loadTiles(TileRange range, boolean force) {
+ if (force) {
+ if (isTooLarge(range)) {
+ Main.warn("Not downloading all tiles because there are too many tiles on an axis!");
+ } else {
+ range.tilePositionsSorted().filter(this::contains).forEach(t -> loadTile(t, force));
+ }
+ }
+ }
+
+ protected static boolean isTooSmall(TileRange range) {
+ return range.tilesSpanned() < 2;
+ }
+
+ protected boolean isTooLarge(TileRange range) {
+ return range.size() > tileCache.getCacheSize() || range.tilesSpanned() > 20;
+ }
+
+ protected boolean loadTile(TilePosition tile, boolean force) {
+ return loadTile(getOrCreateTile(tile), force);
+ }
+
+ private boolean loadTile(Tile tile, boolean force) {
+ if (tile == null)
+ return false;
+ if (!force && (tile.isLoaded() || tile.hasError() || isOverzoomed(tile)))
+ return false;
+ if (tile.isLoading())
+ return false;
+ tileLoader.createTileLoaderJob(tile).submit(force);
+ return true;
+ }
+
+ @Override
+ public void zoomChanged() {
+ if (tileLoader instanceof TMSCachedTileLoader) {
+ ((TMSCachedTileLoader) tileLoader).cancelOutstandingTasks();
+ }
+ }
+
+ /**
+ * Test if a tile is visible.
+ * @param t The tile to test
+ * @return true if it is visible
+ */
+ public static boolean isVisible(Tile t) {
+ return t != null && t.isLoaded() && !t.hasError();
+ }
+
+ /**
+ * Test if a tile is missing.
+ * @param t The tile to test
+ * @return true if it is loading or not loaded yet.
+ */
+ public static boolean isMissing(Tile t) {
+ return t == null || t.isLoading();
+ }
+
+ /**
+ * Test if a tile is marked as loading.
+ * @param t The tile to test
+ * @return true if it is loading
+ */
+ public static boolean isLoading(Tile t) {
+ return t != null && t.isLoading();
+ }
+
+ /**
+ * Test if a tile is marked as overzoomed.
+ * @param t The tile to test
+ * @return true if it is overzoomed
+ */
+ public static boolean isOverzoomed(Tile t) {
+ return t != null && "no-tile".equals(t.getValue("tile-info"));
+ }
+
+ /**
+ * Reserve the memory for the cache
+ * @return true if it is reserved.
+ */
+ protected boolean allocateCacheMemory() {
+ if (memory == null) {
+ MemoryManager manager = MemoryManager.getInstance();
+ if (manager.isAvailable(getEstimatedCacheSize())) {
+ try {
+ memory = manager.allocateMemory("tile source layer", getEstimatedCacheSize(), Object::new);
+ } catch (NotEnoughMemoryException e) {
+ Main.warn("Could not allocate tile source memory", e);
+ }
+ }
+ }
+ return memory != null;
+ }
+
+ /**
+ * Free the cache memeory
+ */
+ protected void freeCacheMemory() {
+ if (memory != null) {
+ memory.free();
+ }
+ }
+
+ protected long getEstimatedCacheSize() {
+ return 4L * tileSource.getTileSize() * tileSource.getTileSize() * estimateTileCacheSize();
+ }
+
+ protected int estimateTileCacheSize() {
+ Dimension screenSize = GuiHelper.getMaximumScreenSize();
+ int height = screenSize.height;
+ int width = screenSize.width;
+ int tileSize = 256; // default tile size
+ if (tileSource != null) {
+ tileSize = tileSource.getTileSize();
+ }
+ // as we can see part of the tile at the top and at the bottom, use Math.ceil(...) + 1 to accommodate for that
+ int visibileTiles = (int) (Math.ceil((double) height / tileSize + 1)
+ * Math.ceil((double) width / tileSize + 1));
+ // add 10% for tiles from different zoom levels
+ // use offset to decide, how many tiles are visible
+ int ret = (int) Math.ceil(Math.pow(2d, AbstractTileSourceLayer.ZOOM_OFFSET.get()) * visibileTiles * 4);
+ Main.info("AbstractTileSourceLayer: estimated visible tiles: {0}, estimated cache size: {1}", visibileTiles,
+ ret);
+ return ret;
+ }
+
+
+ protected class FlushTileCacheAction extends AbstractAction {
+ FlushTileCacheAction() {
+ super(tr("Flush tile cache"));
+ setEnabled(tileLoader instanceof CachedTileLoader);
+ }
+
+ @Override
+ public void actionPerformed(ActionEvent ae) {
+ new PleaseWaitRunnable(tr("Flush tile cache")) {
+ @Override
+ protected void realRun() {
+ clearTileCache();
+ }
+
+ @Override
+ protected void finish() {
+ // empty - flush is instaneus
+ }
+
+ @Override
+ protected void cancel() {
+ // empty - flush is instaneus
+ }
+
+ /**
+ * Clears the tile cache.
+ */
+ private void clearTileCache() {
+ if (tileLoader instanceof CachedTileLoader) {
+ ((CachedTileLoader) tileLoader).clearCache(tileSource);
+ }
+ tileCache.clear();
+ }
+ }.run();
+ }
+ }
+}
diff --git a/src/org/openstreetmap/josm/gui/layer/imagery/TextPainter.java b/src/org/openstreetmap/josm/gui/layer/imagery/TextPainter.java
new file mode 100644
index 0000000..580758e
--- /dev/null
+++ b/src/org/openstreetmap/josm/gui/layer/imagery/TextPainter.java
@@ -0,0 +1,105 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.gui.layer.imagery;
+
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.geom.AffineTransform;
+
+/**
+ * This class handles text painting on the tile source layer.
+ * @author Michael Zangl
+ * @since xxx
+ */
+public class TextPainter {
+ private Graphics2D g;
+ private int debugY;
+ private int overlayY;
+
+ /**
+ * Reset internal state and start.
+ * @param g The graphics to paint on
+ */
+ public void start(Graphics2D g) {
+ this.g = g;
+ debugY = 160;
+ overlayY = 100;
+ }
+
+ /**
+ * Add a debug string
+ * @param debugLine The debug line
+ */
+ public void addDebug(String debugLine) {
+ debugY += drawString(debugLine, 50, debugY, 500);
+ }
+
+ /**
+ * Draw a string onto a given tile.
+ * @param text The text to draw
+ * @param tile The tile to paint on
+ * @param converter A converter to convert the tile to screen coordinates.
+ */
+ public void drawTileString(String text, TilePosition tile, TileCoordinateConverter converter) {
+ AffineTransform transform = converter.getTransformForTile(tile, 0, 0, 0, .5, 1, .5);
+ transform.scale(1.0 / 200, 1.0 / 200);
+ AffineTransform oldTransform = g.getTransform();
+ g.transform(transform);
+ drawString(text, 10, 10, 180);
+ g.setTransform(oldTransform);
+ }
+
+ /**
+ * Add a text overlay for the map.
+ * @param text The text to add.
+ */
+ public void addTextOverlay(String text) {
+ overlayY += drawString(text, 120, overlayY, 500);
+ }
+
+ private int drawString(String text, int x, int y, int width) {
+ String textToDraw = text;
+ int maxLineWidth = 0;
+ int wholeLineWidth = g.getFontMetrics().stringWidth(text);
+ if (wholeLineWidth > width) {
+ // text longer than tile size, split it
+ StringBuilder line = new StringBuilder();
+ StringBuilder ret = new StringBuilder();
+ for (String s: text.split(" ")) {
+ int lineWidth = g.getFontMetrics().stringWidth(line.toString() + s);
+ if (lineWidth > width) {
+ ret.append(line).append('\n');
+ line.setLength(0);
+ lineWidth = g.getFontMetrics().stringWidth(s);
+ }
+ line.append(s).append(' ');
+ maxLineWidth = Math.max(lineWidth, maxLineWidth);
+ }
+ ret.append(line);
+ textToDraw = ret.toString();
+ } else {
+ maxLineWidth = wholeLineWidth;
+ }
+
+ return drawLines(x, y, textToDraw.split("\n"), maxLineWidth);
+ }
+
+ private int drawLines(int x, int y, String[] lines, int maxLineWidth) {
+ int height = g.getFontMetrics().getHeight();
+
+ // background
+ g.setColor(new Color(0, 0, 0, 50));
+ g.fillRect(x - 3, y - height - 1, maxLineWidth + 6, (3 + height) * lines.length + 2);
+
+ int offset = 0;
+ for (String s: lines) {
+ // shadow
+ g.setColor(Color.black);
+ g.drawString(s, x + 1, y + offset + 1);
+ g.setColor(Color.lightGray);
+ g.drawString(s, x, y + offset);
+ offset += height + 3;
+ }
+ return offset;
+ }
+
+}
diff --git a/src/org/openstreetmap/josm/gui/layer/imagery/TileCoordinateConverter.java b/src/org/openstreetmap/josm/gui/layer/imagery/TileCoordinateConverter.java
index ff368e5..fc76dce 100644
--- a/src/org/openstreetmap/josm/gui/layer/imagery/TileCoordinateConverter.java
+++ b/src/org/openstreetmap/josm/gui/layer/imagery/TileCoordinateConverter.java
@@ -1,18 +1,21 @@
// License: GPL. For details, see LICENSE file.
package org.openstreetmap.josm.gui.layer.imagery;
+import java.awt.Shape;
+import java.awt.geom.AffineTransform;
import java.awt.geom.Point2D;
-import java.awt.geom.Rectangle2D;
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.Bounds;
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;
+import org.openstreetmap.josm.gui.MapViewState.MapViewLatLonRectangle;
import org.openstreetmap.josm.gui.MapViewState.MapViewPoint;
+import org.openstreetmap.josm.gui.layer.AbstractTileSourceLayer;
+import org.openstreetmap.josm.tools.Utils;
/**
* This class handles tile coordinate management and computes their position in the map view.
@@ -20,8 +23,7 @@ import org.openstreetmap.josm.gui.MapViewState.MapViewPoint;
* @since 10651
*/
public class TileCoordinateConverter {
- private MapView mapView;
- private TileSourceDisplaySettings settings;
+ private MapViewState displacedState;
private TileSource tileSource;
/**
@@ -30,22 +32,13 @@ public class TileCoordinateConverter {
* @param tileSource The tile source to use when converting coordinates.
* @param settings displacement settings.
*/
- public TileCoordinateConverter(MapView mapView, TileSource tileSource, TileSourceDisplaySettings settings) {
- this.mapView = mapView;
+ public TileCoordinateConverter(MapViewState mapView, TileSource tileSource, TileSourceDisplaySettings settings) {
+ this.displacedState = mapView.shifted(settings.getDisplacement());
this.tileSource = tileSource;
- this.settings = settings;
}
- 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());
+ protected MapViewPoint pos(ICoordinate ll) {
+ return displacedState.getPointFor(new LatLon(ll));
}
/**
@@ -63,11 +56,137 @@ public class TileCoordinateConverter {
* @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());
+ public MapViewLatLonRectangle getAreaForTile(TilePosition tile) {
+ MapViewPoint p1 = tileUV(tile, 0, 0);
+ MapViewPoint p2 = tileUV(tile, 1, 1);
- return pos(c1).rectTo(pos(c2)).getInView();
+ return p1.latLonRectTo(p2);
+ }
+
+ /**
+ * Gets an affine transform that maps image u/v (0..1) space to east/north space.
+ *
+ * You need to scale it by the image size to draw the buffered image.
+ * @param tile
+ * @param u1
+ * @param v1
+ * @param u2
+ * @param v2
+ * @param u3
+ * @param v3
+ * @return the transform
+ */
+ public AffineTransform getTransformForTile(TilePosition tile, double u1, double v1, double u2, double v2, double u3, double v3) {
+ MapViewPoint p1 = tileUV(tile, u1, v1);
+ MapViewPoint p2 = tileUV(tile, u2, v2);
+ MapViewPoint p3 = tileUV(tile, u3, v3);
+
+ // We compute the matrix in a way that p_i.inView is mapped to the corresponding image position.
+ // ( u1 ) ( m00 m01 m02 ) (p1.viewX )
+ // ( v1 ) * ( m10 m11 m12 ) = (p1.viewY )
+ // ( 1 ) ( 0 0 1 ) (1 )
+ // ( u2 ) ( m00 m01 m02 ) (p2.viewX )
+ // ( v2 ) * ( m10 m11 m12 ) = (p2.viewY )
+ // ( 1 ) ( 0 0 1 ) (1 )
+ // ( u3 ) ( m00 m01 m02 ) (p3.viewX )
+ // ( v3 ) * ( m10 m11 m12 ) = (p3.viewY )
+ // ( 1 ) ( 0 0 1 ) (1 )
+
+ // u1 * m00 + v1 * m01 + m02 = p1.viewX
+ // u2 * m00 + v2 * m01 + m02 = p2.viewX
+ // u3 * m00 + v3 * m01 + m02 = p3.viewX
+ // u1 * m10 + v1 * m11 + m12 = p1.viewY
+ // u2 * m10 + v2 * m11 + m12 = p2.viewY
+ // u3 * m10 + v3 * m11 + m12 = p3.viewY
+
+ // u1 * m00 + v1 * m01 + m02 = p1.viewX
+ // (u2 - u1) * m00 + (v2 - v1) * m01 = p2.viewX - p1.viewX
+ // (u3 - u1) * m00 + (v3 - v1) * m01 = p3.viewX - p1.viewX
+
+ // if v2 != v1 and v3 != v1
+ // (u2 - u1) / (v2 - v1) * m00 + m01 = (p2.viewX - p1.viewX) / (v2 - v1)
+ // (u3 - u1) / (v3 - v1) * m00 + m01 = (p3.viewX - p1.viewX) / (v3 - v1)
+
+ // m00 = ((p2.viewX - p1.viewX) / (v2 - v1) - (p3.viewX - p1.viewX) / (v3 - v1)) / ((u2 - u1) / (v2 - v1) - (u3 - u1) / (v3 - v1))
+ // m01 = (p3.viewX - p1.viewX) / (v3 - v1) - (u3 - u1) / (v3 - v1) * m00
+ // m02 = p1.viewX - u1 * m00 + v1 * m01
+
+ // if v2 == v1:
+ // u1 * m00 + v1 * m01 + m02 = p1.viewX
+ // (u2 - u1) * m00 + = p2.viewX - p1.viewX
+ // (u3 - u1) * m00 + (v3 - v1) * m01 = p3.viewX - p1.viewX
+
+ // if v3 == v1
+ // u1 * m00 + v1 * m01 + m02 = p1.viewX
+ // (u2 - u1) * m00 + (v2 - v1) * m01 = p2.viewX - p1.viewX
+ // (u3 - u1) * m00 + = p3.viewX - p1.viewX
+
+
+ double du2 = u2 - u1;
+ double du3 = u3 - u1;
+ double dv2 = v2 - v1;
+ double dv3 = v3 - v1;
+
+ // x space
+ double p1x = p1.getInView().getX();
+ double p2x = p2.getInView().getX();
+ double p3x = p3.getInView().getX();
+
+ double m00;
+ double m01;
+ if (Utils.equalsEpsilon(0, dv2)) {
+ if (Utils.equalsEpsilon(0, du2) || Utils.equalsEpsilon(0, dv3)) {
+ // unsolveable
+ return new AffineTransform();
+ }
+ m00 = (p2x - p1x) / du2;
+ m01 = (p3x - p1x) / dv3 - du3 / dv3 * m00;
+ } else if (Utils.equalsEpsilon(0, dv3)) {
+ if (Utils.equalsEpsilon(0, du3)) {
+ // unsolveable
+ return new AffineTransform();
+ }
+ m00 = (p3x - p1x) / du3;
+ m01 = (p2x - p1x) / dv2 - du2 / dv2 * m00;
+ } else {
+ m00 = ((p2x - p1x) / dv2 - (p3x - p1x) / dv3) / (du2 / dv2 - du3 / dv3);
+ m01 = (p3x - p1x) / dv3 - du3 / dv3 * m00;
+ }
+ double m02 = p1x - u1 * m00 + v1 * m01;
+
+ // y space
+ double p1y = p1.getInView().getY();
+ double p2y = p2.getInView().getY();
+ double p3y = p3.getInView().getY();
+ double m10;
+ double m11;
+ if (Utils.equalsEpsilon(0, dv2)) {
+ m10 = (p2y - p1y) / du2;
+ m11 = (p3y - p1y) / dv3 - du3 / dv3 * m10;
+ } else if (Utils.equalsEpsilon(0, dv3)) {
+ m10 = (p3y - p1y) / du3;
+ m11 = (p2y - p1y) / dv2 - du2 / dv2 * m10;
+ } else {
+ m10 = ((p2y - p1y) / dv2 - (p3y - p1y) / dv3) / (du2 / dv2 - du3 / dv3);
+ m11 = (p3y - p1y) / dv3 - du3 / dv3 * m10;
+ }
+ double m12 = p1y - u1 * m10 + v1 * m11;
+
+ return new AffineTransform(new double[] {
+ m00, m10, m01, m11, m02, m12
+ });
+ }
+
+ private MapViewPoint tileUV(TilePosition tile, double u, double v) {
+ ICoordinate tileLatLon = tileSource.tileXYToLatLon(tile.getX(), tile.getY(), tile.getZoom());
+ if (Utils.equalsEpsilon(0, u) && Utils.equalsEpsilon(0, v)) {
+ return pos(tileLatLon);
+ } else {
+ ICoordinate nextTile = tileSource.tileXYToLatLon(tile.getX() + 1, tile.getY() + 1, tile.getZoom());
+ return displacedState.getPointFor(new LatLon(
+ (1 - v) * tileLatLon.getLat() + v * nextTile.getLat(),
+ (1 - u) * tileLatLon.getLon() + u * nextTile.getLon()));
+ }
}
/**
@@ -76,14 +195,62 @@ public class TileCoordinateConverter {
* @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;
+ Bounds area = displacedState.getViewArea().getCornerBounds();
+ TileXY t1 = tileSource.latLonToTileXY(area.getMin().toCoordinate(), zoom);
+ TileXY t2 = tileSource.latLonToTileXY(area.getMax().toCoordinate(), zoom);
+
+ double screenPixels = displacedState.getViewWidth() * displacedState.getViewHeight();
+ int tileSize = tileSource.getTileSize();
+ double tilePixels = Math.abs((t2.getY() - t1.getY()) * (t2.getX() - t1.getX()) * tileSize * tileSize);
+ if (screenPixels < 1e-10 || tilePixels < 1e-10) {
+ return 1;
+ } else {
+ return screenPixels / tilePixels;
+ }
+ }
+
+ /**
+ * Get the tiles in view at the given zoom level.
+ * @param zoom The zoom level
+ * @return The tiles that are in the view.
+ */
+ public TileRange getViewAtZoom(int zoom) {
+ Bounds view = displacedState.getViewArea().getLatLonBoundsBox();
+ view = view.intersect(displacedState.getProjection().getWorldBoundsLatLon());
+ if (view == null) {
+ return new TileRange();
+ } else {
+ TileXY t1 = tileSource.latLonToTileXY(view.getMin().toCoordinate(), zoom);
+ TileXY t2 = tileSource.latLonToTileXY(view.getMax().toCoordinate(), zoom);
+ return new TileRange(t1, t2, zoom);
+ }
+ }
+
+ /**
+ * Gets the mathematically best zoom. May be out of range.
+ * @return The zoom
+ */
+ public int getBestZoom() {
+ double factor = getScaleFactor(1); // check the ratio between area of tilesize at zoom 1 to current view
+ double result = Math.log(factor) / Math.log(2) / 2;
+ /*
+ * Math.log(factor)/Math.log(2) - gives log base 2 of factor
+ * We divide result by 2, as factor contains ratio between areas. We could do Math.sqrt before log, or just divide log by 2
+ *
+ * ZOOM_OFFSET controls, whether we work with overzoomed or underzoomed tiles. Positive ZOOM_OFFSET
+ * is for working with underzoomed tiles (higher quality when working with aerial imagery), negative ZOOM_OFFSET
+ * is for working with overzoomed tiles (big, pixelated), which is good when working with high-dpi screens and/or
+ * maps as a imagery layer
+ */
+
+ return (int) Math.round(result + 1 + AbstractTileSourceLayer.ZOOM_OFFSET.get() / 1.9);
+ }
+
+ /**
+ * Gets the clip to use to only paint inside the projection
+ * @return The clip.
+ */
+ public Shape getProjectionClip() {
+ return displacedState.getArea(displacedState.getProjection().getWorldBoundsLatLon());
}
}
diff --git a/src/org/openstreetmap/josm/gui/layer/imagery/TileForAreaFinder.java b/src/org/openstreetmap/josm/gui/layer/imagery/TileForAreaFinder.java
new file mode 100644
index 0000000..3410390
--- /dev/null
+++ b/src/org/openstreetmap/josm/gui/layer/imagery/TileForAreaFinder.java
@@ -0,0 +1,114 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.gui.layer.imagery;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.data.Bounds;
+
+/**
+ * This class helps finding loaded tiles for a tile area.
+ * @author Michael Zangl
+ * @since xxx
+ */
+public final class TileForAreaFinder {
+
+ private TileForAreaFinder() {
+ // hidden
+ }
+
+ /**
+ * Get a stream of all tile positions to paint for the given zoom level.
+ * @param initialRange The range
+ * @param rangeProducer An object that converts between {@link Bounds} and {@link TilePosition}
+ * @return A stream of tiles to paint.
+ */
+ public static Stream getAtDefaultZoom(TileRange initialRange, TileForAreaGetter rangeProducer) {
+ return initialRange.tilePositions().filter(rangeProducer::isAvailable);
+ }
+
+ /**
+ * Gets a stream of all positions to be painted taking the fallback zoom levels into account.
+ *
+ * Limiting the resulting stream won't change the performance of this method. It returns a stream so that this may be changed in the future.
+ *
+ * @param initialRange The range
+ * @param rangeProducer An object that converts between {@link Bounds} and {@link TilePosition}
+ * @param zoom The zoom levels to try at.
+ * @return A stream of tiles to paint.
+ */
+ public static Stream getWithFallbackZoom(TileRange initialRange, TileForAreaGetter rangeProducer, ZoomLevelManager zoom) {
+ ArrayList list = new ArrayList<>();
+ List> missedInPreviousRuns = new ArrayList<>();
+ List missed = initialRange.tilePositions().flatMap(pos -> addPosition(pos, rangeProducer, list)).collect(Collectors.toList());
+ List missedInLastRun = missed;
+
+ for (int delta : new int[] { -1, 1, -2, 2, -3, -4, -5 }) {
+ int zoomLevel = delta + initialRange.getZoom();
+ if (zoomLevel >= zoom.getMinZoom() && zoomLevel <= zoom.getMaxZoom()) {
+ missed = missedInLastRun
+ .stream()
+ .flatMap(b -> rangeProducer.toRangeAtZoom(b, zoomLevel).tilePositions())
+ .distinct()
+ .filter(tile -> missedInPreviousRuns.stream().allMatch(l -> l.stream().anyMatch(rangeProducer.getBounds(tile)::intersects)))
+ .flatMap(pos -> addPosition(pos, rangeProducer, list))
+ .collect(Collectors.toList());
+ Main.trace("Still missed {0} tile areas at zoom {1}.", missed.size(), zoomLevel);
+ if (missed.isEmpty()) {
+ break;
+ }
+
+ missedInPreviousRuns.add(missedInLastRun);
+ missedInLastRun = missed;
+ }
+ // no break condition. But missed will be empty, so flatMap should not be costy.
+ }
+
+ Collections.reverse(list);
+ return list.stream().distinct();
+ }
+
+ private static Stream addPosition(TilePosition pos, TileForAreaGetter rangeProducer, ArrayList addTo) {
+ if (rangeProducer.isAvailable(pos)) {
+ addTo.add(pos);
+ return Stream.empty();
+ } else {
+ return Stream.of(rangeProducer.getBounds(pos));
+ }
+ }
+
+ /**
+ * Classes implementing this interface allow us to convert between a tile range and {@link Bounds}.
+ * @author Michael Zangl
+ * @since xxx
+ */
+ public interface TileForAreaGetter {
+ /**
+ * Gets a tile range that is enclosing this tile at the given zoom level.
+ * @param bounds The bounds to get the range for
+ * @param zoom The zoom the range should be at
+ * @return The range for the given bounds.
+ */
+ public TileRange toRangeAtZoom(Bounds bounds, int zoom);
+
+ /**
+ * Gets the bounds for a tile
+ * @param tile The tile
+ * @return The bounds for that tile
+ */
+ public Bounds getBounds(TilePosition tile);
+
+ /**
+ * Checks if an image is available for the given tile
+ * @param tile The tile to check
+ * @return True if it is available.
+ */
+ public boolean isAvailable(TilePosition tile);
+
+ }
+
+}
diff --git a/src/org/openstreetmap/josm/gui/layer/imagery/TilePosition.java b/src/org/openstreetmap/josm/gui/layer/imagery/TilePosition.java
new file mode 100644
index 0000000..c823341
--- /dev/null
+++ b/src/org/openstreetmap/josm/gui/layer/imagery/TilePosition.java
@@ -0,0 +1,111 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.gui.layer.imagery;
+
+import java.io.Serializable;
+
+import org.openstreetmap.gui.jmapviewer.Tile;
+import org.openstreetmap.gui.jmapviewer.TileXY;
+
+/**
+ * The position of a single tile. In contrast to {@link TileXY}, this stores the position of the whole tile.
+ * @author Michael Zangl
+ * @since xxx
+ */
+public class TilePosition implements Serializable {
+ private static final long serialVersionUID = 1;
+
+ private final int x;
+ private final int y;
+ private final int zoom;
+
+ /**
+ * Create a new tile position object
+ * @param x The x coordinate
+ * @param y The y coordinate
+ * @param zoom The zoom at which the tile is.
+ */
+ TilePosition(int x, int y, int zoom) {
+ super();
+ this.x = x;
+ this.y = y;
+ this.zoom = zoom;
+ }
+
+ /**
+ * Create a new tile position object
+ * @param tile The tile from wich the position should be copied.
+ */
+ public TilePosition(Tile tile) {
+ this(tile.getXtile(), tile.getYtile(), tile.getZoom());
+ }
+
+ /**
+ * @return the x position
+ */
+ public int getX() {
+ return x;
+ }
+
+ /**
+ * @return the y position
+ */
+ public int getY() {
+ return y;
+ }
+
+ /**
+ * @return the zoom
+ */
+ public int getZoom() {
+ return zoom;
+ }
+
+ /**
+ * Gets an x/y coordinate inside this tile
+ * @param du x delta. Range should be 0..1
+ * @param dv y delta. Range should be 0..1
+ * @return The x/y coordinate
+ */
+ public TileXY uv(double du, double dv) {
+ return new TileXY(getX() + du, getY() + dv);
+ }
+
+ /* (non-Javadoc)
+ * @see java.lang.Object#hashCode()
+ */
+ @Override
+ public int hashCode() {
+ final int prime = 31;
+ int result = 1;
+ result = prime * result + x;
+ result = prime * result + y;
+ result = prime * result + zoom;
+ return result;
+ }
+
+ /* (non-Javadoc)
+ * @see java.lang.Object#equals(java.lang.Object)
+ */
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj)
+ return true;
+ if (obj == null)
+ return false;
+ if (getClass() != obj.getClass())
+ return false;
+ TilePosition other = (TilePosition) obj;
+ if (x != other.x)
+ return false;
+ if (y != other.y)
+ return false;
+ if (zoom != other.zoom)
+ return false;
+ return true;
+ }
+
+ @Override
+ public String toString() {
+ return "TilePosition [x=" + x + ", y=" + y + ", zoom=" + zoom + "]";
+ }
+}
diff --git a/src/org/openstreetmap/josm/gui/layer/imagery/TileRange.java b/src/org/openstreetmap/josm/gui/layer/imagery/TileRange.java
new file mode 100644
index 0000000..901447d
--- /dev/null
+++ b/src/org/openstreetmap/josm/gui/layer/imagery/TileRange.java
@@ -0,0 +1,81 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.gui.layer.imagery;
+
+import java.util.Comparator;
+import java.util.function.Function;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+import org.openstreetmap.gui.jmapviewer.TileXY;
+
+/**
+ * This is a rectangular range of tiles.
+ */
+class TileRange {
+ int minX;
+ int maxX;
+ int minY;
+ int maxY;
+ int zoom;
+
+ TileRange() {
+ }
+
+ 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;
+ }
+
+ protected double tilesSpanned() {
+ return Math.sqrt(1.0 * this.size());
+ }
+
+ protected int size() {
+ int xSpan = maxX - minX + 1;
+ int ySpan = maxY - minY + 1;
+ return xSpan * ySpan;
+ }
+
+ /**
+ * @return comparator, that sorts the tiles from the center to the edge of the current screen
+ */
+ private Comparator getTileDistanceComparator() {
+ final int centerX = (int) Math.ceil((minX + maxX) / 2d);
+ final int centerY = (int) Math.ceil((minY + maxY) / 2d);
+ return Comparator.comparingInt(t -> Math.abs(t.getX() - centerX) + Math.abs(t.getY() - centerY));
+ }
+
+ /**
+ * Gets a stream of all tile positions in this set
+ * @return A stream of all positions
+ */
+ public Stream tilePositions() {
+ if (zoom == 0) {
+ return Stream.empty();
+ } else {
+ return IntStream.rangeClosed(minX, maxX).mapToObj(
+ x -> IntStream.rangeClosed(minY, maxY).mapToObj(y -> new TilePosition(x, y, zoom))
+ ).flatMap(Function.identity());
+ }
+ }
+
+ /**
+ * Gets all tile positions with the ones in the center of the view first.
+ * @return The tile positions
+ * @see #tilePositions()
+ */
+ public Stream tilePositionsSorted() {
+ return tilePositions().sorted(getTileDistanceComparator());
+ }
+
+ /**
+ * Get the zoom level this range is for
+ * @return The zoom.
+ */
+ public int getZoom() {
+ return zoom;
+ }
+}
diff --git a/src/org/openstreetmap/josm/gui/layer/imagery/TileSourceDisplaySettings.java b/src/org/openstreetmap/josm/gui/layer/imagery/TileSourceDisplaySettings.java
index 67ab88a..f766ac2 100644
--- a/src/org/openstreetmap/josm/gui/layer/imagery/TileSourceDisplaySettings.java
+++ b/src/org/openstreetmap/josm/gui/layer/imagery/TileSourceDisplaySettings.java
@@ -212,7 +212,7 @@ public class TileSourceDisplaySettings {
* @param changedSetting The setting name
*/
private void fireSettingsChange(String changedSetting) {
- DisplaySettingsChangeEvent e = new DisplaySettingsChangeEvent(changedSetting);
+ DisplaySettingsChangeEvent e = new DisplaySettingsChangeEvent(this, changedSetting);
for (DisplaySettingsChangeListener l : listeners) {
l.displaySettingsChanged(e);
}
@@ -332,13 +332,24 @@ public class TileSourceDisplaySettings {
* @author Michael Zangl
*/
public static final class DisplaySettingsChangeEvent {
+ private final TileSourceDisplaySettings source;
private final String changedSetting;
- DisplaySettingsChangeEvent(String changedSetting) {
+ DisplaySettingsChangeEvent(TileSourceDisplaySettings source, String changedSetting) {
+ this.source = source;
this.changedSetting = changedSetting;
}
/**
+ * Gets the display settings that caused this event.
+ * @return The settings.
+ * @since xxx
+ */
+ public TileSourceDisplaySettings getSource() {
+ return source;
+ }
+
+ /**
* Gets the setting that was changed
* @return The name of the changed setting.
*/
diff --git a/src/org/openstreetmap/josm/gui/layer/imagery/TileSourcePainter.java b/src/org/openstreetmap/josm/gui/layer/imagery/TileSourcePainter.java
new file mode 100644
index 0000000..9dd7ad7
--- /dev/null
+++ b/src/org/openstreetmap/josm/gui/layer/imagery/TileSourcePainter.java
@@ -0,0 +1,563 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.gui.layer.imagery;
+
+import static org.openstreetmap.josm.tools.I18n.tr;
+
+import java.awt.Color;
+import java.awt.Font;
+import java.awt.Graphics2D;
+import java.awt.GridBagLayout;
+import java.awt.Image;
+import java.awt.Rectangle;
+import java.awt.Shape;
+import java.awt.Toolkit;
+import java.awt.event.ActionEvent;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Rectangle2D;
+import java.awt.image.BufferedImage;
+import java.awt.image.ImageObserver;
+import java.io.IOException;
+import java.text.MessageFormat;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Date;
+import java.util.List;
+import java.util.Map.Entry;
+import java.util.Objects;
+import java.util.stream.Stream;
+
+import javax.swing.AbstractAction;
+import javax.swing.Action;
+import javax.swing.BorderFactory;
+import javax.swing.JLabel;
+import javax.swing.JMenuItem;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JPopupMenu;
+import javax.swing.JSeparator;
+import javax.swing.JTextField;
+import javax.swing.event.PopupMenuEvent;
+import javax.swing.event.PopupMenuListener;
+
+import org.openstreetmap.gui.jmapviewer.Tile;
+import org.openstreetmap.gui.jmapviewer.TileXY;
+import org.openstreetmap.gui.jmapviewer.interfaces.ICoordinate;
+import org.openstreetmap.gui.jmapviewer.tilesources.AbstractTMSTileSource;
+import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.data.Bounds;
+import org.openstreetmap.josm.data.imagery.TMSCachedTileLoader;
+import org.openstreetmap.josm.data.projection.Projection;
+import org.openstreetmap.josm.gui.ExtendedDialog;
+import org.openstreetmap.josm.gui.MapView;
+import org.openstreetmap.josm.gui.MapViewState.MapViewLatLonRectangle;
+import org.openstreetmap.josm.gui.MapViewState.MapViewPoint;
+import org.openstreetmap.josm.gui.MapViewState.MapViewRectangle;
+import org.openstreetmap.josm.gui.layer.AbstractTileSourceLayer;
+import org.openstreetmap.josm.gui.layer.ImageryLayer;
+import org.openstreetmap.josm.gui.layer.MapViewGraphics;
+import org.openstreetmap.josm.gui.layer.MapViewPaintable.LayerPainter;
+import org.openstreetmap.josm.gui.layer.MapViewPaintable.MapViewEvent;
+import org.openstreetmap.josm.tools.GBC;
+import org.openstreetmap.josm.tools.Pair;
+
+/**
+ * This class is used to paint a {@link AbstractTileSourceLayer} to a given map view.
+ * @author Michael Zangl
+ * @param The imagery type to use
+ * @since xxx
+ */
+public class TileSourcePainter extends AbstractTileSourceLoader implements LayerPainter {
+ /**
+ *
+ */
+ protected final AbstractTileSourceLayer layer;
+ private static final Font INFO_FONT = new Font("sansserif", Font.BOLD, 13);
+ /**
+ * Absolute maximum of tiles to paint
+ */
+ private static final int MAX_TILES = 500;
+
+ protected final ZoomLevelManager zoom;
+
+ private final TextPainter textPainter;
+
+ private TilePosition highlightPosition;
+
+ final MouseAdapter adapter = new TilePainterMouseAdapter();
+
+ private final MapView mapView;
+
+ /**
+ * Create a new {@link TileSourcePainter}
+ * @param layer The layer to paint
+ * @param mapView The map view to paint for.
+ */
+ public TileSourcePainter(AbstractTileSourceLayer layer, MapView mapView) {
+ super(layer);
+ this.layer = layer;
+ this.mapView = mapView;
+ mapView.addMouseListener(adapter);
+
+ textPainter = new TextPainter();
+ zoom = new ZoomLevelManager(getSettings(), tileSource, generateCoordinateConverter());
+ zoom.setZoomBounds(layer.getInfo());
+ }
+
+ @Override
+ public void paint(MapViewGraphics graphics) {
+ boolean hasAllocated = allocateCacheMemory();
+
+ textPainter.start(graphics.getDefaultGraphics());
+
+ if (hasAllocated) {
+ doPaint(graphics);
+ } else {
+ textPainter.addTextOverlay(tr("There is noth enough memory to display this layer."));
+ }
+ }
+
+ private void doPaint(MapViewGraphics graphics) {
+ MapViewRectangle pb = graphics.getClipBounds();
+
+ drawInViewArea(graphics.getDefaultGraphics(), graphics.getMapView(), pb);
+ }
+
+ private void drawInViewArea(Graphics2D g, MapView mapView, MapViewRectangle rect) {
+ g.setFont(INFO_FONT);
+ TileCoordinateConverter converter = generateCoordinateConverter();
+ zoom.updateZoomLevel(converter, this);
+ loadTilesInView(converter);
+
+ TileRange baseRange = converter.getViewAtZoom(zoom.getCurrentZoomLevel());
+
+ Shape clip = g.getClip();
+ g.setClip(converter.getProjectionClip());
+ Stream area;
+ if (getSettings().isAutoZoom()) {
+ area = TileForAreaFinder.getWithFallbackZoom(baseRange, this, zoom);
+ } else {
+ area = TileForAreaFinder.getAtDefaultZoom(baseRange, this);
+ }
+ paintTileImages(g, area);
+ g.setClip(clip);
+
+ if (highlightPosition != null) {
+ paintHighlight(g, converter, highlightPosition);
+ }
+ paintStatus(baseRange, mapView.getProjection());
+ paintAttribution(g, rect);
+ if (Main.isDebugEnabled()) {
+ paintDebug();
+ }
+ }
+
+ /**
+ * Paints a highlight rectangle around a tile.
+ * @param g
+ * @param converter
+ * @param tile
+ */
+ private static void paintHighlight(Graphics2D g, TileCoordinateConverter converter, TilePosition tile) {
+ MapViewLatLonRectangle area = converter.getAreaForTile(tile);
+ g.setColor(Color.RED);
+ g.draw(area.getInView());
+ }
+
+ /**
+ * Paint the filtered images for the given tiles
+ * @param g The graphics to paint on
+ * @param area The tiles to paint.
+ */
+ private void paintTileImages(Graphics2D g, Stream area) {
+ TileCoordinateConverter converter = generateCoordinateConverter();
+ Rectangle b = g.getClipBounds();
+ int maxTiles = (int) (b.getWidth() * b.getHeight() / tileSource.getTileSize() / tileSource.getTileSize() * 5);
+ List errorTiles = Collections.synchronizedList(new ArrayList<>());
+ Stream tiles = area.parallel()
+ .limit(Math.min(maxTiles, MAX_TILES))
+ .map(this::getTile)
+ .filter(Objects::nonNull);
+
+ if (getSettings().isShowErrors()) {
+ tiles = tiles.peek(t -> { if (t.hasError()) errorTiles.add(t); });
+ }
+ tiles.map(tile -> new Pair<>(tile, tile.getImage()))
+ .filter(p -> imageLoaded(p.b))
+ .map(p -> new Pair<>(p.a, layer.applyImageProcessors(p.b)))
+ .forEachOrdered(p -> paintTileImage(g, p.a, p.b, converter));
+
+ for (Tile error : errorTiles) {
+ textPainter.drawTileString(tr("Error") + ": " + tr(error.getErrorMessage()),
+ new TilePosition(error), converter);
+ }
+ }
+
+ /**
+ * We only paint full tile images.
+ *
+ * We handle that the correct tile images are in front by sorting the list of tiles accordingly.
+ * @param g The graphics to paint on
+ * @param tile The tile to paint
+ * @param image The image to paint for the tile
+ * @param converter The coordinate converter.
+ */
+ private void paintTileImage(Graphics2D g, Tile tile, BufferedImage image, TileCoordinateConverter converter) {
+ AffineTransform transform = converter.getTransformForTile(new TilePosition(tile), 0, 0, 0, 1, 1, 1);
+ transform.scale(1.0 / image.getWidth(), 1.0 / image.getHeight());
+
+ g.drawImage(image, transform, layer);
+
+ if (ImageryLayer.PROP_FADE_AMOUNT.get() != 0) {
+ // dimm by painting opaque rect...
+ // TODO: Convert this to a filter.
+ g.setColor(ImageryLayer.getFadeColorWithAlpha());
+ AffineTransform oldTrans = g.getTransform();
+ g.transform(transform);
+ g.fillRect(0, 0, image.getWidth(), image.getHeight());
+ g.setTransform(oldTrans);
+ }
+
+ if (Main.isTraceEnabled()) {
+ textPainter.drawTileString(tile.getKey(), new TilePosition(tile), converter);
+ }
+ }
+
+ private void paintAttribution(Graphics2D defaultGraphics, MapViewRectangle rect) {
+ Rectangle2D inView = rect.getInView();
+ Graphics2D g = (Graphics2D) defaultGraphics.create();
+ g.translate(inView.getMinX(), inView.getMinY());
+ Bounds boundsBox = rect.getLatLonBoundsBox();
+ attribution.paintAttribution(g, (int) inView.getWidth(), (int) inView.getHeight(),
+ boundsBox.getMin().toCoordinate(), boundsBox.getMax().toCoordinate(), zoom.getDisplayZoomLevel(),
+ layer);
+ }
+
+ private void paintStatus(TileRange baseRange, Projection projection) {
+ if (isTooLarge(baseRange)) {
+ textPainter.addTextOverlay(tr("zoom in to load more tiles"));
+ } else if (!getSettings().isAutoZoom() && isTooSmall(baseRange)) {
+ textPainter.addTextOverlay(tr("increase tiles zoom level (change resolution) to see more detail"));
+ } else if (getSettings().isAutoZoom() && getSettings().isAutoLoad() && !hasTiles(baseRange, TileSourcePainter::isVisible)
+ && (!hasTiles(baseRange, TileSourcePainter::isLoading) || hasTiles(baseRange, TileSourcePainter::isOverzoomed))) {
+ textPainter.addTextOverlay(tr("No tiles at this zoom level"));
+ }
+
+ if (!isProjectionSupported(projection)) {
+ textPainter.addTextOverlay(tr("The tile source does not support the current projection natively"));
+ }
+ }
+
+ private void paintDebug() {
+ for (String s : zoom.getDebugInfo(generateCoordinateConverter())) {
+ textPainter.addDebug(s);
+ }
+ textPainter.addDebug(tr("Estimated cache size: {0}", estimateTileCacheSize()));
+ if (tileLoader instanceof TMSCachedTileLoader) {
+ TMSCachedTileLoader cachedTileLoader = (TMSCachedTileLoader) tileLoader;
+ for (String part : cachedTileLoader.getStats().split("\n")) {
+ textPainter.addDebug(tr("Cache stats: {0}", part));
+ }
+ }
+ }
+
+ private void loadTilesInView(TileCoordinateConverter converter) {
+ int zoomToLoad = zoom.getDisplayZoomLevel();
+ TileRange range = converter.getViewAtZoom(zoomToLoad);
+
+ if (getSettings().isAutoZoom()) {
+ // If all tiles at displayZoomLevel is loaded, load all tiles at next zoom level
+ // to make sure there're really no more zoom levels
+ if (zoomToLoad < zoom.getCurrentZoomLevel() && !hasTiles(range, TileSourcePainter::isMissing)) {
+ zoomToLoad++;
+ range = converter.getViewAtZoom(zoomToLoad);
+ } else {
+ // When we have overzoomed tiles and all tiles at current zoomlevel is loaded,
+ // load tiles at previovus zoomlevels until we have all tiles on screen is loaded.
+ // loading is done in the next if section
+ while (zoomToLoad > zoom.getMinZoom() && hasTiles(range, TileSourcePainter::isOverzoomed)
+ && !hasTiles(range, TileSourcePainter::isMissing)) {
+ zoomToLoad--;
+ range = converter.getViewAtZoom(zoomToLoad);
+ }
+ }
+ }
+ loadTiles(range, false);
+ }
+
+ private void loadErrorTiles(TileRange range, boolean force) {
+ if (getSettings().isAutoLoad() || force) {
+ range.tilePositionsSorted().map(this::getOrCreateTile).filter(Tile::hasError)
+ .forEach(t -> tileLoader.createTileLoaderJob(t).submit(force));
+ }
+ }
+
+ protected void loadAllErrorTiles(boolean force) {
+ loadErrorTiles(generateCoordinateConverter().getViewAtZoom(zoom.getCurrentZoomLevel()), force);
+ }
+
+ protected void loadAllTiles(boolean force) {
+ loadTiles(generateCoordinateConverter().getViewAtZoom(zoom.getCurrentZoomLevel()), force);
+ }
+
+ @Override
+ protected void loadTiles(TileRange range, boolean force) {
+ super.loadTiles(range, force || getSettings().isAutoLoad());
+ }
+
+ private boolean imageLoaded(Image i) {
+ if (i == null) {
+ return false;
+ } else {
+ int status = Toolkit.getDefaultToolkit().checkImage(i, -1, -1, layer);
+ return (status & ImageObserver.ALLBITS) != 0;
+ }
+ }
+
+ private TileCoordinateConverter generateCoordinateConverter() {
+ return new TileCoordinateConverter(mapView.getState(), tileSource, getSettings());
+ }
+
+ /**
+ * Check whether this layer supports the given projection
+ * @param projection The projection to search
+ * @return true if supported.
+ */
+ protected boolean isProjectionSupported(Projection projection) {
+ return true;
+ }
+
+ private TileSourceDisplaySettings getSettings() {
+ return layer.getDisplaySettings();
+ }
+
+ /**
+ * Gets the menu entries for this layer
+ * @return The menu entries
+ */
+ public List getMenuEntries() {
+ return Arrays.asList(zoom.new IncreaseZoomAction(), zoom.new DecreaseZoomAction(),
+ zoom.new ZoomToBestAction(mapView), zoom.new ZoomToNativeLevelAction(mapView),
+ new FlushTileCacheAction(), new LoadErroneusTilesAction(), new LoadAllTilesAction());
+ }
+
+ /**
+ * Gets the current zoom level as String
+ * @return The zoom level.
+ */
+ public String getZoomString() {
+ return Integer.toString(zoom.getCurrentZoomLevel());
+ }
+
+ @Override
+ public void detachFromMapView(MapViewEvent event) {
+ event.getMapView().removeMouseListener(adapter);
+ MapView.removeZoomChangeListener(this);
+ freeCacheMemory();
+ layer.detach(this);
+ }
+
+ private final class TilePainterMouseAdapter extends MouseAdapter {
+ @Override
+ public void mouseClicked(MouseEvent e) {
+ if (e.getButton() == MouseEvent.BUTTON3) {
+ TilePosition tilePos = getTileForPixelpos(mapView.getState().getForView(e.getPoint()));
+ JPopupMenu popup = layer.new TileSourceLayerPopup(mapView);
+ popup.addPopupMenuListener(new PopupMenuListener() {
+ @Override
+ public void popupMenuWillBecomeVisible(PopupMenuEvent e) {
+ highlightPosition = tilePos;
+ // triggers repaint
+ layer.invalidate();
+ }
+
+ @Override
+ public void popupMenuWillBecomeInvisible(PopupMenuEvent e) {
+ highlightPosition = null;
+ layer.invalidate();
+ }
+
+ @Override
+ public void popupMenuCanceled(PopupMenuEvent e) {
+ // ignore
+ }
+ });
+ if (tilePos != null) {
+ popup.add(new JSeparator());
+ popup.add(new JMenuItem(new LoadTileAction(tilePos)));
+ Tile tile = getOrCreateTile(tilePos);
+ if (tile != null) {
+ popup.add(new JMenuItem(new ShowTileInfoAction(tile)));
+ }
+ }
+ popup.show(e.getComponent(), e.getX(), e.getY());
+ } else if (e.getButton() == MouseEvent.BUTTON1) {
+ attribution.handleAttribution(e.getPoint(), true);
+ }
+ }
+
+ /**
+ * Returns tile for a pixel position.
+ * This isn't very efficient, but it is only used when the user right-clicks on the map.
+ * @param mapViewPoint pixel coordinate
+ * @return Tile at pixel position
+ */
+ private TilePosition getTileForPixelpos(MapViewPoint mapViewPoint) {
+ Main.trace("getTileForPixelpos({0})", mapViewPoint);
+ TileCoordinateConverter converter = generateCoordinateConverter();
+
+ TileRange ts = converter.getViewAtZoom(zoom.getCurrentZoomLevel());
+
+ Stream clickedTiles = ts.tilePositions()
+ .filter(t -> converter.getAreaForTile(t).contains(mapViewPoint));
+ if (Main.isTraceEnabled()) {
+ clickedTiles = clickedTiles.peek(t -> Main.trace("Clicked on tile: {0}, {1}; currentZoomLevel: {2}",
+ t.getX(), t.getY(), zoom.getCurrentZoomLevel()));
+ }
+ return clickedTiles.findAny().orElse(null);
+ }
+ }
+
+ private class LoadAllTilesAction extends AbstractAction {
+ LoadAllTilesAction() {
+ super(tr("Load all tiles"));
+ }
+
+ @Override
+ public void actionPerformed(ActionEvent ae) {
+ loadAllTiles(true);
+ }
+ }
+
+ private class LoadErroneusTilesAction extends AbstractAction {
+ LoadErroneusTilesAction() {
+ super(tr("Load all error tiles"));
+ }
+
+ @Override
+ public void actionPerformed(ActionEvent ae) {
+ loadAllErrorTiles(true);
+ }
+ }
+
+ private final class ShowTileInfoAction extends AbstractAction {
+
+ private final transient Tile clickedTile;
+
+ private ShowTileInfoAction(Tile clickedTile) {
+ super(tr("Show tile info"));
+ this.clickedTile = clickedTile;
+ }
+
+ private String getSizeString(int size) {
+ StringBuilder ret = new StringBuilder();
+ return ret.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;
+ }
+
+ @Override
+ public void actionPerformed(ActionEvent ae) {
+ ExtendedDialog ed = new ExtendedDialog(Main.parent, tr("Tile Info"), new String[] { tr("OK") });
+ JPanel panel = new JPanel(new GridBagLayout());
+ MapViewLatLonRectangle displaySize = generateCoordinateConverter().getAreaForTile(new TilePosition(clickedTile));
+ Rectangle2D bounds = displaySize.getInView().getBounds2D();
+ String[][] content = { { "Tile name", clickedTile.getKey() }, { "Tile url", getUrl() },
+ { "Tile size", getSizeString(clickedTile.getTileSource().getTileSize()) },
+ { "Position in view", MessageFormat.format("x={0}..{1}, y={2}..{3}",
+ bounds.getMinX(), bounds.getMaxX(),
+ bounds.getMinY(), bounds.getMaxY())},
+ { "Position on projection",MessageFormat.format("east={0}..{1}, north={2}..{3}",
+ displaySize.getProjectionBounds().minEast, displaySize.getProjectionBounds().maxEast,
+ displaySize.getProjectionBounds().minNorth, displaySize.getProjectionBounds().maxNorth)},
+ { "Position on world",MessageFormat.format("lat={0}..{1}, lon={2}..{3}",
+ displaySize.getLatLonBoundsBox().getMinLat(), displaySize.getLatLonBoundsBox().getMaxLat(),
+ displaySize.getLatLonBoundsBox().getMinLon(), displaySize.getLatLonBoundsBox().getMaxLon())},
+ };
+
+ for (String[] entry : content) {
+ panel.add(new JLabel(tr(entry[0]) + ':'), GBC.std());
+ panel.add(GBC.glue(5, 0), GBC.std());
+ panel.add(createTextField(entry[1]), GBC.eol().fill(GBC.HORIZONTAL));
+ }
+
+ for (Entry e : clickedTile.getMetadata().entrySet()) {
+ panel.add(new JLabel(tr("Metadata ") + tr(e.getKey()) + ':'), GBC.std());
+ panel.add(GBC.glue(5, 0), GBC.std());
+ String value = e.getValue();
+ if ("lastModification".equals(e.getKey()) || "expirationTime".equals(e.getKey())) {
+ value = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date(Long.parseLong(value)));
+ }
+ panel.add(createTextField(value), GBC.eol().fill(GBC.HORIZONTAL));
+
+ }
+ ed.setIcon(JOptionPane.INFORMATION_MESSAGE);
+ ed.setContent(panel);
+ ed.showDialog();
+ }
+
+ private String getUrl() {
+ try {
+ return clickedTile.getUrl();
+ } catch (IOException e) {
+ // silence exceptions
+ Main.trace(e);
+ return "";
+ }
+ }
+ }
+
+ private final class LoadTileAction extends AbstractAction {
+
+ private final transient TilePosition clickedTile;
+
+ private LoadTileAction(TilePosition clickedTile) {
+ super(tr("Load tile"));
+ this.clickedTile = clickedTile;
+ setEnabled(clickedTile != null);
+ }
+
+ @Override
+ public void actionPerformed(ActionEvent ae) {
+ loadTile(clickedTile, true);
+ layer.invalidate();
+ }
+ }
+
+ @Override
+ public Bounds getBounds(TilePosition tilePos) {
+ ICoordinate min = tileSource.tileXYToLatLon(tilePos.getX(), tilePos.getY(), tilePos.getZoom());
+ ICoordinate max = tileSource.tileXYToLatLon(tilePos.getX() + 1, tilePos.getY() + 1, tilePos.getZoom());
+ Bounds bounds = new Bounds(min.getLat(), min.getLon(), false);
+ bounds.extend(max.getLat(), max.getLon());
+ return bounds;
+ }
+
+ @Override
+ public TileRange toRangeAtZoom(Bounds bounds, int zoom) {
+ TileXY t1 = tileSource.latLonToTileXY(bounds.getMinLat(), bounds.getMinLon(), zoom);
+ TileXY t2 = tileSource.latLonToTileXY(bounds.getMaxLat(), bounds.getMaxLon(), zoom);
+ return new TileRange(t1, t2, zoom);
+ }
+
+ @Override
+ public boolean isAvailable(TilePosition tilePos) {
+ Tile tile = getTile(tilePos);
+ return tile != null && !tile.hasError()
+ && !(isOverzoomed(tile) && tilePos.getZoom() > zoom.getDisplayZoomLevel())
+ && isImageAvailable(tile);
+ }
+
+ private boolean isImageAvailable(Tile tile) {
+ BufferedImage image = tile.getImage();
+ return imageLoaded(image);
+ }
+}
diff --git a/src/org/openstreetmap/josm/gui/layer/imagery/ZoomLevelManager.java b/src/org/openstreetmap/josm/gui/layer/imagery/ZoomLevelManager.java
new file mode 100644
index 0000000..fe0fea4
--- /dev/null
+++ b/src/org/openstreetmap/josm/gui/layer/imagery/ZoomLevelManager.java
@@ -0,0 +1,297 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.gui.layer.imagery;
+
+import static org.openstreetmap.josm.tools.I18n.tr;
+
+import java.awt.event.ActionEvent;
+import java.text.MessageFormat;
+import java.util.Arrays;
+import java.util.List;
+
+import javax.swing.AbstractAction;
+
+import org.openstreetmap.gui.jmapviewer.Tile;
+import org.openstreetmap.gui.jmapviewer.interfaces.TileSource;
+import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.data.imagery.ImageryInfo;
+import org.openstreetmap.josm.gui.MapView;
+import org.openstreetmap.josm.gui.layer.AbstractTileSourceLayer;
+
+/**
+ * This class manages the zoom level of a {@link TileSourcePainter}
+ * @author Michael Zangl
+ * @since xxx
+ */
+public class ZoomLevelManager {
+ /**
+ * Zoomlevel selected by the user.
+ */
+ private int currentZoomLevel;
+ /**
+ * The zoom level at which tiles are currently displayed
+ */
+ private int displayZoomLevel;
+ private TileSourceDisplaySettings settings;
+ private TileSource source;
+
+ private int minZoom;
+ private int maxZoom;
+
+ /**
+ * Create a new zoom level manager
+ * @param settings The zoom settings
+ * @param source The tile source to use.
+ * @param initialZoomState The initial state to compute the zoom factor from.
+ */
+ public ZoomLevelManager(TileSourceDisplaySettings settings, TileSource source, TileCoordinateConverter initialZoomState) {
+ this.settings = settings;
+ this.source = source;
+
+ setZoomLevel(clampZoom(initialZoomState.getBestZoom()));
+ setZoomBounds(source.getMinZoom(), source.getMaxZoom());
+ }
+
+ /**
+ * Set the zoom bounds
+ * @param bounds An info to get the zoom bounds from
+ */
+ public void setZoomBounds(ImageryInfo bounds) {
+ setZoomBounds(bounds.getMinZoom(), bounds.getMaxZoom());
+ }
+
+ /**
+ * Sets the zoom bounds
+ * @param minZoom The minimum zoom
+ * @param maxZoom The maximum zoom.
+ */
+ public void setZoomBounds(int minZoom, int maxZoom) {
+ if (minZoom > maxZoom || minZoom < 0) {
+ throw new IllegalArgumentException(MessageFormat.format("Zoom range not valid: {0}..{1}", minZoom, maxZoom));
+ }
+ this.minZoom = AbstractTileSourceLayer.checkMinZoomLvl(minZoom, source);
+ this.maxZoom = AbstractTileSourceLayer.checkMaxZoomLvl(maxZoom, source);
+ }
+
+ /**
+ * @return The min zoom that was set.
+ */
+ public int getMinZoom() {
+ return minZoom;
+ }
+
+ /**
+ * @return The max zoom that was set.
+ */
+ public int getMaxZoom() {
+ return maxZoom;
+ }
+
+ /**
+ *
+ * @return if its allowed to zoom in
+ */
+ public boolean zoomIncreaseAllowed() {
+ boolean zia = currentZoomLevel < this.getMaxZoom();
+ if (Main.isDebugEnabled()) {
+ Main.debug("zoomIncreaseAllowed(): " + zia + ' ' + currentZoomLevel + " vs. " + this.getMaxZoom());
+ }
+ return zia;
+ }
+
+ /**
+ * Zoom in, go closer to map.
+ *
+ * @return true, if zoom increasing was successful, false otherwise
+ */
+ public boolean increaseZoomLevel() {
+ return setZoomLevel(currentZoomLevel + 1);
+ }
+
+ /**
+ * Sets the zoom level of the layer
+ * @param zoom zoom level
+ * @return true, when zoom has changed to desired value, false if it was outside supported zoom levels
+ */
+ public boolean setZoomLevel(int zoom) {
+ if (zoom == currentZoomLevel && zoom == displayZoomLevel) {
+ return true;
+ } else if (zoom < getMinZoom() || zoom > getMaxZoom()) {
+ Main.warn("Current zoom level ({0}) could not be changed to {1}: out of range {2} .. {3}", currentZoomLevel,
+ zoom, getMinZoom(), getMaxZoom());
+ return false;
+ } else {
+ Main.debug("changing zoom level to: {0}", currentZoomLevel);
+ currentZoomLevel = zoom;
+ displayZoomLevel = zoom;
+ return true;
+ }
+ }
+
+ /**
+ * Check if zooming out is allowed
+ *
+ * @return true, if zooming out is allowed (currentZoomLevel > minZoomLevel)
+ */
+ public boolean zoomDecreaseAllowed() {
+ boolean zda = currentZoomLevel > this.getMinZoom();
+ if (Main.isDebugEnabled()) {
+ Main.debug("zoomDecreaseAllowed(): " + zda + ' ' + currentZoomLevel + " vs. " + this.getMinZoom());
+ }
+ return zda;
+ }
+
+ /**
+ * Zoom out from map.
+ *
+ * @return true, if zoom increasing was successfull, false othervise
+ */
+ public boolean decreaseZoomLevel() {
+ return setZoomLevel(currentZoomLevel - 1);
+ }
+
+ /**
+ * Update the zoom level that should be displayed
+ * @param currentZoomState The coordinate converter that holds the current view
+ * @param viewStatus An accessor for finding out if the given tiles are available.
+ */
+ public void updateZoomLevel(TileCoordinateConverter currentZoomState, TileSourcePainter viewStatus) {
+ if (settings.isAutoZoom()) {
+ int zoom = clampZoom(currentZoomState.getBestZoom());
+ setZoomLevel(zoom);
+ if (settings.isAutoLoad()) {
+ // Find highest zoom level with at least one visible tile
+
+ for (int tmpZoom = zoom; tmpZoom >= getMinZoom(); tmpZoom--) {
+ TileRange area = currentZoomState.getViewAtZoom(zoom);
+ if (viewStatus.hasTiles(area, ZoomLevelManager::visibleOrOverzoomed)) {
+ displayZoomLevel = tmpZoom;
+ break;
+ }
+ }
+ }
+ } else {
+ displayZoomLevel = currentZoomLevel;
+ }
+ }
+
+ private static boolean visibleOrOverzoomed(Tile t) {
+ return TileSourcePainter.isVisible(t) || TileSourcePainter.isOverzoomed(t);
+ }
+
+ private int clampZoom(int intResult) {
+ return Math.max(Math.min(intResult, getMaxZoom()), getMinZoom());
+ }
+
+ /**
+ * Gets the current zoom level that is requested by the user for displaying the tiles.
+ * @return The current zoom level of the view
+ */
+ public int getCurrentZoomLevel() {
+ return currentZoomLevel;
+ }
+
+ /**
+ * Gets the zoom level that is suggested to be displayed. This may be different depending on the tile loading settings.
+ * @return The suggested zoom.
+ */
+ public int getDisplayZoomLevel() {
+ return displayZoomLevel;
+ }
+
+ /**
+ * Gets the debug information that should be added about the zoom level.
+ * @param currentZoomState A coordinate converter
+ * @return The current zoom status.
+ */
+ public List getDebugInfo(TileCoordinateConverter currentZoomState) {
+ int bestZoom = currentZoomState.getBestZoom();
+ return Arrays.asList(
+ tr("Current zoom: {0}", getCurrentZoomLevel()),
+ tr("Display zoom: {0}", displayZoomLevel),
+ tr("Pixel scale: {0}", currentZoomState.getScaleFactor(getCurrentZoomLevel())),
+ tr("Best zoom: {0} (clamped to: {1})", bestZoom, clampZoom(bestZoom))
+ );
+ }
+
+ /**
+ * Zooms to the native level of the current view
+ */
+ public class ZoomToNativeLevelAction extends AbstractAction {
+ private final MapView forView;
+
+ /**
+ * Create a new {@link ZoomToNativeLevelAction}
+ * @param forView The map view to zoom
+ */
+ public ZoomToNativeLevelAction(MapView forView) {
+ super(tr("Zoom to native resolution"));
+ this.forView = forView;
+ }
+
+ @Override
+ public void actionPerformed(ActionEvent ae) {
+ TileCoordinateConverter converter = new TileCoordinateConverter(forView.getState(), source, settings);
+ double newFactor = Math.sqrt(converter.getScaleFactor(currentZoomLevel));
+ forView.zoomToFactor(newFactor);
+ }
+ }
+
+ /**
+ * Zooms the layer to the best display zoom for the current map view state
+ */
+ public class ZoomToBestAction extends AbstractAction {
+ private final int bestZoom;
+
+ /**
+ * Create a new {@link ZoomToBestAction}
+ * @param forView The view to use as reference.
+ */
+ public ZoomToBestAction(MapView forView) {
+ super(tr("Change resolution"));
+ bestZoom = clampZoom(new TileCoordinateConverter(forView.getState(), source, settings).getBestZoom());
+ setEnabled(!settings.isAutoZoom() && bestZoom != currentZoomLevel);
+ }
+
+ @Override
+ public void actionPerformed(ActionEvent ae) {
+ setZoomLevel(bestZoom);
+ }
+ }
+
+ /**
+ * Increase the zoom by 1.
+ */
+ public class IncreaseZoomAction extends AbstractAction {
+ /**
+ * Create a new {@link IncreaseZoomAction}
+ */
+ public IncreaseZoomAction() {
+ super(tr("Increase zoom"));
+ setEnabled(!settings.isAutoZoom() && zoomIncreaseAllowed());
+ }
+
+ @Override
+ public void actionPerformed(ActionEvent ae) {
+ increaseZoomLevel();
+ }
+ }
+
+ /**
+ * Decrease the zoom by 1.
+ */
+ public class DecreaseZoomAction extends AbstractAction {
+ /**
+ * Create a new {@link DecreaseZoomAction}
+ */
+ public DecreaseZoomAction() {
+ super(tr("Decrease zoom"));
+ setEnabled(!settings.isAutoZoom() && zoomDecreaseAllowed());
+ }
+
+ @Override
+ public void actionPerformed(ActionEvent ae) {
+ decreaseZoomLevel();
+ }
+ }
+
+}
diff --git a/test/unit/org/openstreetmap/josm/gui/layer/imagery/TileCoordinateConverterTest.java b/test/unit/org/openstreetmap/josm/gui/layer/imagery/TileCoordinateConverterTest.java
new file mode 100644
index 0000000..b673d61
--- /dev/null
+++ b/test/unit/org/openstreetmap/josm/gui/layer/imagery/TileCoordinateConverterTest.java
@@ -0,0 +1,289 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.gui.layer.imagery;
+
+import static org.junit.Assert.assertEquals;
+
+import java.awt.Image;
+import java.awt.Point;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Point2D;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.openstreetmap.gui.jmapviewer.Coordinate;
+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.JOSMFixture;
+import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.data.coor.EastNorth;
+import org.openstreetmap.josm.data.coor.LatLon;
+import org.openstreetmap.josm.gui.MapFrame;
+import org.openstreetmap.josm.gui.MapViewState;
+import org.openstreetmap.josm.gui.MapViewState.MapViewLatLonRectangle;
+import org.openstreetmap.josm.gui.MapViewState.MapViewPoint;
+import org.openstreetmap.josm.gui.layer.LayerManagerTest;
+import org.openstreetmap.josm.gui.util.GuiHelper;
+
+/**
+ * Test {@link TileCoordinateConverter}
+ * @author Michael Zangl
+ * @since xxx
+ */
+public class TileCoordinateConverterTest {
+ private static final class TransformingConverter extends TileCoordinateConverter {
+ AffineTransform transform = new AffineTransform();
+
+ private TransformingConverter(MapViewState mapView, TileSource tileSource, TileSourceDisplaySettings settings) {
+ super(mapView, tileSource, settings);
+ }
+
+ @Override
+ protected MapViewPoint pos(ICoordinate ll) {
+ Point2D transformed = transform.transform(new Point2D.Double(ll.getLat(), ll.getLon()), null);
+ return super.pos(new Coordinate(transformed.getX(), transformed.getY()));
+ }
+ }
+
+ private static final class TestTileSource implements TileSource {
+ @Override
+ public boolean requiresAttribution() {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public String getTermsOfUseURL() {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public String getTermsOfUseText() {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public String getAttributionText(int zoom, ICoordinate topLeft, ICoordinate botRight) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public String getAttributionLinkURL() {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public String getAttributionImageURL() {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public Image getAttributionImage() {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public Point latLonToXY(ICoordinate point, int zoom) {
+ return latLonToXY(point.getLat(), point.getLon(), zoom);
+ }
+
+ @Override
+ public ICoordinate xyToLatLon(Point point, int zoom) {
+ return xyToLatLon(point.x, point.y, zoom);
+ }
+
+ @Override
+ public TileXY latLonToTileXY(ICoordinate point, int zoom) {
+ return latLonToTileXY(point.getLat(), point.getLon(), zoom);
+ }
+
+ @Override
+ public ICoordinate tileXYToLatLon(TileXY xy, int zoom) {
+ return tileXYToLatLon(xy.getXIndex(), xy.getYIndex(), zoom);
+ }
+
+ @Override
+ public ICoordinate tileXYToLatLon(Tile tile) {
+ return tileXYToLatLon(tile.getXtile(), tile.getYtile(), tile.getZoom());
+ }
+
+ @Override
+ public boolean isNoTileAtZoom(Map> headers, int statusCode, byte[] content) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public int getTileYMin(int zoom) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public int getTileYMax(int zoom) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public int getTileXMin(int zoom) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public int getTileXMax(int zoom) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public String getTileUrl(int zoom, int tilex, int tiley) throws IOException {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public int getTileSize() {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public String getTileId(int zoom, int tilex, int tiley) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public String getName() {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public int getMinZoom() {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public Map getMetadata(Map> headers) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public int getMaxZoom() {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public String getId() {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public double getDistance(double la1, double lo1, double la2, double lo2) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public int getDefaultTileSize() {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public Point latLonToXY(double lat, double lon, int zoom) {
+ return new Point((int) lat / 13, (int) lon - 4);
+ }
+
+ @Override
+ public ICoordinate xyToLatLon(int x, int y, int zoom) {
+ return new Coordinate(x * 13, y + 4);
+ }
+
+ @Override
+ public TileXY latLonToTileXY(double lat, double lon, int zoom) {
+ return new TileXY(lat / 13, lon - 4);
+ }
+
+ @Override
+ public ICoordinate tileXYToLatLon(int x, int y, int zoom) {
+ return new Coordinate(x * 13, y + 4);
+ }
+ }
+
+ private TransformingConverter converter;
+
+ /**
+ * Setup test.
+ */
+ @BeforeClass
+ public static void setUpBeforeClass() {
+ JOSMFixture.createUnitTestFixture().init(true);
+ Main.getLayerManager().addLayer(new LayerManagerTest.TestLayer());
+ GuiHelper.runInEDTAndWait(() -> {});
+ }
+
+ /**
+ * Sets up a fake tile source.
+ */
+ @Before
+ public void setUp() {
+ MapFrame map = Main.map;
+ map.mapView.zoomTo(new EastNorth(0, 0), 1);
+ converter = new TransformingConverter(map.mapView.getState(), new TestTileSource(), new TileSourceDisplaySettings());
+ }
+
+ /**
+ * Test {@link TileCoordinateConverter#getAreaForTile(TilePosition)}
+ */
+ @Test
+ public void testGetAreaForTile() {
+ EastNorth p1 = Main.getProjection().latlon2eastNorth(new LatLon(26, 7));
+ MapViewLatLonRectangle rect = converter.getAreaForTile(new TilePosition(2, 3, 1));
+ assertEquals(p1.getX(), rect.getProjectionBounds().minEast, 1e-10);
+ assertEquals(p1.getY(), rect.getProjectionBounds().minNorth, 1e-10);
+ }
+
+ /**
+ * Test {@link TileCoordinateConverter#getTransformForTile(TilePosition, double, double, double, double, double, double)}
+ */
+ @Test
+ public void testGetTransformForTile() {
+ TilePosition tile = new TilePosition(2, 3, 1);
+ Point2D p1 = Main.map.mapView.getState().getPointFor(new LatLon(26, 7)).getInView();
+ Point2D p2 = Main.map.mapView.getState().getPointFor(new LatLon(39, 8)).getInView();
+
+ for (AffineTransform transform : new AffineTransform[] {
+ converter.getTransformForTile(tile, 0, 0, 0, 1, 1, 1),
+ converter.getTransformForTile(tile, 0, 0, 1, 0, 1, 1),
+ converter.getTransformForTile(tile, 0, 0, 1, 1, 1, 0),
+ converter.getTransformForTile(tile, 0, 0, 0, 1, 1, 0),
+ }) {
+ assertEquals(p1.getX(), transform.getTranslateX(), 1e-10);
+ assertEquals(p1.getY(), transform.getTranslateY(), 1e-10);
+
+ Point2D p1converted = transform.transform(new Point2D.Double(0, 0), null);
+ Point2D p2converted = transform.transform(new Point2D.Double(1, 1), null);
+
+ assertEquals(p1.getX(), p1converted.getX(), 1e-10);
+ assertEquals(p1.getY(), p1converted.getY(), 1e-10);
+ assertEquals(p2.getX(), p2converted.getX(), 1e-10);
+ assertEquals(p2.getY(), p2converted.getY(), 1e-10);
+ }
+ }
+ /**
+ * Test {@link TileCoordinateConverter#getTransformForTile(TilePosition, double, double, double, double, double, double)}
+ * ignores unsolveable
+ */
+ @Test
+ public void testGetTransformForTileIgnoresUnsolveable() {
+ TilePosition tile = new TilePosition(2, 3, 1);
+ for (AffineTransform transform : new AffineTransform[] {
+ converter.getTransformForTile(tile, 0, 0, 0, 0, 1, 1),
+ converter.getTransformForTile(tile, 0, 0, 1, 0, 0.5, 0),
+ converter.getTransformForTile(tile, 0, 0, 1, 1, 0, 0),
+ converter.getTransformForTile(tile, 0, 0, 0, 0e-30, 1, 0),
+ }) {
+ assertEquals(1, transform.getScaleX(), 1e-10);
+ assertEquals(1, transform.getScaleY(), 1e-10);
+ assertEquals(0, transform.getTranslateX(), 1e-10);
+ assertEquals(0, transform.getTranslateY(), 1e-10);
+ }
+ }
+}