Changeset 14732 in osm

Timestamp:

2009-04-24T19:34:33+02:00 (16 years ago)

Author:

lvarga

Message:

Applyied patch from Dave Hansen <dave@…>. His info about changes:

1. Change tileStorage from being a set of arrays of hashmaps (one per zoom level) to being a single hash. We do this by adding a 'level' variable to the SlippyMapKey class. This simplifies the code a good amount, and gets rid of a warning when allocating the HashMap array.
2. Introduce SlippyMapLayer.loadSingleTile(). This not only forces the image to get loaded, but also checks the state of the entire tileStorage, looking for extra tiles.
3. Add crude timestamping to SlippyMapTile. Whenever a load of a SlippyMapTile is requested, we timestamp it. This lets us figure out which have been least recently used later.
4. Bound the size of the tileStorage. Every so often, go look at all of the tiles. Sort them by access time. Drop the image from the tile if it isn't one of the 100 most recent ones. (Make this a preference?)
5. Add some sanity checks to SlippyMapKey to make sure we don't add negative indexes. This keeps us from requesting urls like: ​http://a.tile.openstreetmap.org/2/-1/-2.png
6. Introduce a new auto-zoom mechanism. Right now, it attempts to see how many tiles are on the screen. This is OK, but it can cause autozoom changes on just scrolling. Say you have a screen which exactly fits 6x6 tiles. If you scroll over just a bit, you'll see all of those 16 tiles, plus a few pixels of the next row over. You'll all of a sudden be seeing 6x7 tiles, and autozoom will kick in. This new mechanism attempts to detect how much tiles are being squished or stretched. Since it has to load a tile before it can actually find out the tile's size, it also has the nice side-effect of getting things drawn on the screen earlier. Should these be preferences too?
7. Add debugging to imageUpdate, printing the URL of images that fail to load. Also add a SlippyMapTile.getImageURL() helper to facilitate this.
8. Make sure we redraw sooner when changing zoom levels

Location:

applications/editors/josm/plugins/slippymap/src/org/openstreetmap/josm/plugins/slippymap

Files:

• SlippyMapKey.java (modified) (6 diffs)
• SlippyMapLayer.java (modified) (17 diffs)
• SlippyMapTile.java (modified) (8 diffs)

applications/editors/josm/plugins/slippymap/src/org/openstreetmap/josm/plugins/slippymap/SlippyMapKey.java

@@ -11 +11 @@
  * 
  * @author LuVar <lubomir.varga@freemap.sk>
+ * @author Dave Hansen <dave@sr71.net>
  *
  */
@@ -16 +17 @@
         private final int x;
         private final int y;
+        private final int level;
         
         /**
@@ -26 +28 @@
          * @param y     y position in tiles table
          */
-        public SlippyMapKey(int x, int y) {
+        public final boolean valid;
+        public SlippyMapKey(int level, int x, int y) {
                 this.x = x;
                 this.y = y;
+                this.level = level;
+                if (level <= 0 || x < 0 || y < 0) {
+                        this.valid = false;
+                        System.err.println("invalid SlippyMapKey("+level+", "+x+", "+y+")");
+                } else {
+                        this.valid = true;
+                }
         }
         
@@ -42 +52 @@
                 if (obj instanceof SlippyMapKey) {
                         SlippyMapKey smk = (SlippyMapKey) obj;
-                        if((smk.x == this.x) && (smk.y == this.y)) {
+                        if((smk.x == this.x) && (smk.y == this.y) && (smk.level == this.level)) {
                                 return true;
                         }
@@ -55 +65 @@
         @Override
         public int hashCode() {
-                return new Integer(this.x + this.y * 10000).hashCode();
+                return new Integer(this.x + this.y * 10000 + this.level * 100000).hashCode();
         }
         
@@ -63 +73 @@
         @Override
         public String toString() {
-                return "SlippyMapKey(x=" + this.x + ",y=" + this.y + ")";
+                return "SlippyMapKey(x=" + this.x + ",y=" + this.y + ",level=" + level + ")";
         }
         

applications/editors/josm/plugins/slippymap/src/org/openstreetmap/josm/plugins/slippymap/SlippyMapLayer.java

@@ -12 +12 @@
 import java.awt.event.MouseEvent;
 import java.awt.image.ImageObserver;
+import java.util.Comparator;
 import java.util.HashMap;
+import java.util.TreeSet;
 
 import javax.swing.AbstractAction;
@@ -37 +39 @@
  * @author Frederik Ramm <frederik@remote.org>
  * @author LuVar <lubomir.varga@freemap.sk>
+ * @author Dave Hansen <dave@sr71.net>
  * 
  */
@@ -46 +49 @@
          */
         public int currentZoomLevel = SlippyMapPreferences.getMinZoomLvl();
-        private HashMap<SlippyMapKey, SlippyMapTile>[] tileStorage = null;
+        private HashMap<SlippyMapKey, SlippyMapTile> tileStorage = null;
 
         Point[][] pixelpos = new Point[21][21];
@@ -68 +71 @@
                         public void actionPerformed(ActionEvent ae) {
                                 if (clickedTile != null) {
-                                        clickedTile.loadImage();
+                                        loadSingleTile(clickedTile);
                                         needRedraw = true;
                                         Main.map.repaint();
@@ -120 +123 @@
                                         public void actionPerformed(ActionEvent ae) {
                                                 decreaseZoomLevel();
-                                                needRedraw = true;
                                                 Main.map.repaint();
                                         }
@@ -162 +164 @@
                 if (currentZoomLevel < SlippyMapPreferences.getMaxZoomLvl()) {
                         currentZoomLevel++;
+                        Main.debug("increasing zoom level to: " + currentZoomLevel);
+                        needRedraw = true;
                 } else {
-                        System.err
-                                        .println("current zoom lvl couldnt be increased. MaxZoomLvl reached.");
+                        System.err.println("current zoom lvl ("+currentZoomLevel+") couldnt be increased. "+
+                                                         "MaxZoomLvl ("+SlippyMapPreferences.getMaxZoomLvl()+") reached.");
                 }
         }
@@ -173 +177 @@
         public void decreaseZoomLevel() {
                 if (currentZoomLevel > SlippyMapPreferences.getMinZoomLvl()) {
+                        Main.debug("decreasing zoom level to: " + currentZoomLevel);
                         currentZoomLevel--;
+                        needRedraw = true;
                 } else {
-                        System.err
-                                        .println("current zoom lvl couldnt be decreased. MinZoomLvl reached.");
+                        System.err.println("current zoom lvl couldnt be decreased. MinZoomLvl reached.");
                 }
         }
@@ -184 +189 @@
                 // the setting isnt saved yet.
                 int maxZoom = 30; // SlippyMapPreferences.getMaxZoomLvl();
-                // +1 because of array indexed from 0.
-                tileStorage = new HashMap[maxZoom + 1];
-
-                for (int i = 0; i < maxZoom + 1; i++)
-                        tileStorage[i] = new HashMap<SlippyMapKey, SlippyMapTile>();
+                tileStorage = new HashMap<SlippyMapKey, SlippyMapTile>();
+
+                checkTileStorage();
+        }
+
+        class TileTimeComp implements Comparator<SlippyMapTile> {
+                        public int compare(SlippyMapTile s1, SlippyMapTile s2) {
+                                        long t1 = s1.access_time();
+                                        long t2 = s2.access_time();
+                                        if (s1 == s2)
+                                                        return 0;
+                                        if (t1 == t2) {
+                                                        t1 = s1.hashCode();
+                                                        t2 = s2.hashCode();
+                                        }
+                                        if (t1 < t2)
+                                                        return -1;
+                                        return 1;
+                        }
+        }
+
+        long lastCheck = 0;
+        /**
+         * <p>
+         * Check if tiles.size() is not more than max_nr_tiles. If yes, oldest tiles by timestamp
+         * are fired out from cache.
+         * </p>
+         */
+        public void checkTileStorage() {
+                int maxZoom = 30; // SlippyMapPreferences.getMaxZoomLvl();
+                long now = System.currentTimeMillis();
+                if (now - lastCheck < 1000)
+                                return;
+                lastCheck = now;
+                TreeSet<SlippyMapTile> tiles = new TreeSet<SlippyMapTile>(new TileTimeComp());
+                tiles.addAll(tileStorage.values());
+                int max_nr_tiles = 100;
+                if (tiles.size() < max_nr_tiles) {
+                        Main.debug("total of " + tiles.size() + " loaded tiles, size OK " + now);
+                        return;
+                }
+                int nr_to_drop = tiles.size() - max_nr_tiles;;
+                Main.debug("total of " + tiles.size() + " tiles, need to flush " + nr_to_drop + " tiles");
+                for (SlippyMapTile t : tiles) {
+                        if (nr_to_drop <= 0)
+                                        break;
+                        t.dropImage();
+                        nr_to_drop--;
+                }
+        }
+
+        void loadSingleTile(SlippyMapTile tile)
+        {
+                tile.loadImage();
+                this.checkTileStorage();
         }
 
@@ -224 +279 @@
                 for (int x = z12x0 - 1; x <= z12x1; x++) {
                         for (int y = z12y0 - 1; y <= z12y1; y++) {
-                                SlippyMapKey key = new SlippyMapKey(x, y);
-
-                                SlippyMapTile tile = tileStorage[currentZoomLevel].get(key);
-
+                                SlippyMapKey key = new SlippyMapKey(currentZoomLevel, x, y);
+                                SlippyMapTile tile = tileStorage.get(key);
+                                if (!key.valid) {
+                                                System.out.println("paint-1() made invalid key");
+                                                continue;
+                                }
                                 if (tile == null)
-                                        tileStorage[currentZoomLevel].put(key,
+                                        tileStorage.put(key,
                                                         tile = new SlippyMapTile(x, y, currentZoomLevel));
-
-                                if (tile.getImage() == null)
-                                        tile.loadImage();
-                        }
-                }
+                                if (tile.getImage() == null) {
+                                        this.loadSingleTile(tile);
+                                }
+                        }
+                }
+        }
+
+        /*
+         * Attempt to approximate how much the image is
+         * being scaled.  For instance, a 100x100 image
+         * being scaled to 50x50 would return 0.25.
+         */
+        double getImageScaling(Image img, Point p0, Point p1)
+        {
+                int realWidth = img.getWidth(this);
+                int realHeight = img.getHeight(this);
+                if (realWidth == -1 || realHeight == -1)
+                                return 1.0;
+                int drawWidth = p1.x - p0.x;
+                int drawHeight = p1.x - p0.x;
+
+                double drawArea = drawWidth * drawHeight;
+                double realArea = realWidth * realHeight;
+
+                return drawArea / realArea;
         }
 
@@ -242 +319 @@
         @Override
         public void paint(Graphics g, MapView mv) {
+                long start = System.currentTimeMillis();
                 LatLon topLeft = mv.getLatLon(0, 0);
                 LatLon botRight = mv.getLatLon(mv.getWidth(), mv.getHeight());
                 Graphics oldg = g;
 
+                if (botRight.lon() == 0.0 || botRight.lat() == 0) {
+                                // probably still initializing
+                                return;
+                }
                 if (lastTopLeft != null && lastBotRight != null
                                 && topLeft.equalsEpsilon(lastTopLeft)
@@ -298 +380 @@
                 float fadeBackground = SlippyMapPreferences.getFadeBackground();
 
+                Double imageScale = null;
+                int count = 0;
                 for (int x = z12x0 - 1; x <= z12x1; x++) {
                         for (int y = z12y0 - 1; y <= z12y1; y++) {
-                                SlippyMapKey key = new SlippyMapKey(x, y);
+                                SlippyMapKey key = new SlippyMapKey(currentZoomLevel, x, y);
                                 SlippyMapTile tile;
-                                try {
-                                        tile = tileStorage[currentZoomLevel].get(key);
-                                } catch (IndexOutOfBoundsException ex) {
-                                        throw new RuntimeException("currentZoomLevel="
-                                                        + currentZoomLevel
-                                                        + " and tile storage array have just size="
-                                                        + tileStorage.length
-                                                        + " and maxZoomLvl in preferences is "
-                                                        + SlippyMapPreferences.getMaxZoomLvl() + ".", ex);
-                                }
-
+                                tile = tileStorage.get(key);
+                                if (!key.valid) {
+                                                System.out.println("loadAllTiles() made invalid key");
+                                                continue;
+                                }
                                 if (tile == null) {
                                         tile = new SlippyMapTile(x, y, currentZoomLevel);
-                                        tileStorage[currentZoomLevel].put(key, tile);
+                                        tileStorage.put(key, tile);
                                         if (SlippyMapPreferences.getAutoloadTiles()) {
                                                 // TODO probably do on background
-                                                tile.loadImage();
-                                        }
+                                                loadSingleTile(tile);
+                                        }
+                                        checkTileStorage();
                                 }
                                 Image img = tile.getImage();
@@ -327 +406 @@
                                         Point p2 = pixelpos[x - z12x0 + 2][y - z12y0 + 2];
                                         g.drawImage(img, p.x, p.y, p2.x - p.x, p2.y - p.y, this);
-
+                                        if (imageScale == null)
+                                                imageScale = new Double(getImageScaling(img, p, p2));
+                                        count++;
                                         if (fadeBackground != 0f) {
                                                 // dimm by painting opaque rect...
@@ -336 +417 @@
                         }// end of for
                 }// end of for
-
                 g.setColor(Color.red);
                 for (int x = z12x0 - 1; x <= z12x1; x++) {
@@ -351 +431 @@
 
                         for (int y = z12y0 - 1; y <= z12y1; y++) {
-                                SlippyMapKey key = new SlippyMapKey(x, y);
+                                SlippyMapKey key = new SlippyMapKey(currentZoomLevel, x, y);
                                 int texty = p.y + 2 + fontHeight;
-                                SlippyMapTile tile = tileStorage[currentZoomLevel].get(key);
+                                SlippyMapTile tile = tileStorage.get(key);
                                 if (tile == null) {
                                         continue;
+                                }
+                                if (!key.valid) {
+                                                System.out.println("paint-0() made invalid key");
+                                                continue;
+                                }
+                                if (tile.getImage() == null) {
+                                                loadSingleTile(tile);
                                 }
                                 p = pixelpos[x - z12x0 + 1][y - z12y0 + 2];
@@ -395 +482 @@
                 oldg.drawImage(bufferImage, 0, 0, null);
 
-                // TODO do autozoom nicer
-                if ((z12x1 - z12x0 < 2) || (z12y1 - z12y0 < 2)) {
-                        if (SlippyMapPreferences.getAutozoom()) {
-                                increaseZoomLevel();
-                        }
-                        this.paint(oldg, mv);
-                }
-
-                if ((z12x1 - z12x0 > 6) || (z12y1 - z12y0 > 6)) {
-                        if (SlippyMapPreferences.getAutozoom()) {
-                                decreaseZoomLevel();
-                        }
-                        this.paint(oldg, mv);
-                }
-                
+                if (imageScale != null) {
+                        // If each source image pixel is being stretched into > 3
+                        // drawn pixels, zoom in... getting too pixelated
+                        if (imageScale > 3) {
+                                if (SlippyMapPreferences.getAutozoom()) {
+                                    Main.debug("autozoom increase: "+z12x1+" " + z12x0 + " " + z12y1 + " " + z12y0
+                                                                        + topLeft + " " + botRight + " scale: " + imageScale);
+                                        increaseZoomLevel();
+                                }
+                                this.paint(oldg, mv);
+                        }
+
+                        // If each source image pixel is being squished into > 0.32
+                        // of a drawn pixels, zoom out.
+                        if (imageScale < 0.32) {
+                                if (SlippyMapPreferences.getAutozoom()) {
+                                    Main.debug("autozoom decrease: "+z12x1+" " + z12x0 + " " + z12y1 + " " + z12y0
+                                                                        + topLeft + " " + botRight + " scale: " + imageScale);
+                                        decreaseZoomLevel();
+                                }
+                                this.paint(oldg, mv);
+                        }
+                }       
                 g.setColor(Color.black);
                 g.drawString("currentZoomLevel=" + currentZoomLevel, 120, 120);
@@ -433 +528 @@
                         }
                 }
-                if (tiley == -1)
+                if (tiley == -1) {
                         return null;
-
-                SlippyMapKey key = new SlippyMapKey(tilex, tiley);
-                SlippyMapTile tile = tileStorage[currentZoomLevel].get(key);
+                }
+
+                SlippyMapKey key = new SlippyMapKey(currentZoomLevel, tilex, tiley);
+                if (!key.valid) {
+                        System.err.println("getTileForPixelpos("+px+","+py+") made invalid key");
+                        return null;
+                }
+                SlippyMapTile tile = tileStorage.get(key);
                 if (tile == null)
-                        tileStorage[currentZoomLevel].put(key, tile = new SlippyMapTile(
-                                        tilex, tiley, currentZoomLevel));
+                        tileStorage.put(key, tile = new SlippyMapTile(tilex, tiley, currentZoomLevel));
+                checkTileStorage();
                 return tile;
         }
@@ -506 +606 @@
         public boolean imageUpdate(Image img, int infoflags, int x, int y,
                         int width, int height) {
-
                 boolean done = ((infoflags & (ERROR | FRAMEBITS | ALLBITS)) != 0);
+                if ((infoflags & ERROR) != 0) {
+                                String url = "unknown";
+                                for (SlippyMapTile tile : tileStorage.values()) {
+                                                if (tile.getImage() != img)
+                                                                continue;
+                                                url = tile.getImageURL().toString();
+                                }
+                                System.err.println("imageUpdate(" + img + ") error " + url +")");
+                }
+                if ((infoflags & SOMEBITS) != 0) {
+                                //if (y%100 == 0)
+                                //      System.out.println("imageUpdate("+img+") SOMEBITS ("+x+","+y+")");
+                }
                 // Repaint immediately if we are done, otherwise batch up
                 // repaint requests every 100 milliseconds

applications/editors/josm/plugins/slippymap/src/org/openstreetmap/josm/plugins/slippymap/SlippyMapTile.java

@@ -16 +16 @@
  * @author Frederik Ramm <frederik@remote.org>
  * @author LuVar <lubomir.varga@freemap.sk>
+ * @author Dave Hansen <dave@sr71.net>
  * 
  */
@@ -21 +22 @@
 {
     private Image  tileImage;
+        long timestamp;
 
     int x;
@@ -33 +35 @@
         this.y = y;
         this.z = z;
+                timestamp = System.currentTimeMillis();
     }
 
@@ -40 +43 @@
     }
 
-    public void loadImage()
+
+    public URL getImageURL()
     {
         try
         {
-            URL imageURL = new URL(SlippyMapPreferences.getMapUrl() + "/" + z
-                    + "/" + x + "/" + y + ".png");
-            
-            tileImage = Toolkit.getDefaultToolkit().createImage(imageURL);
+            return new URL(SlippyMapPreferences.getMapUrl() + "/" + z + "/" + x + "/" + y + ".png");
         }
         catch (MalformedURLException mfu)
@@ -53 +54 @@
             mfu.printStackTrace();
         }
+            return null;
+        }
+
+    public void loadImage()
+    {
+        URL imageURL = this.getImageURL();
+        tileImage = Toolkit.getDefaultToolkit().createImage(imageURL);
+                Toolkit.getDefaultToolkit().sync();
+                timestamp = System.currentTimeMillis();
     }
 
     public Image getImage()
     {
+        timestamp = System.currentTimeMillis();
         return tileImage;
+    }
+
+    public void dropImage()
+    {
+                tileImage = null;
+                //  This should work in theory but doesn't seem to actually
+                //  reduce the X server memory usage
+                //tileImage.flush();
     }
 
@@ -74 +93 @@
         catch (Exception ex)
         {
-            metadata = tr("error loading metadata");
+            metadata = tr("error loading metadata" + ex.toString());
         }
 
@@ -88 +107 @@
             BufferedReader in = new BufferedReader(new InputStreamReader(devc
                     .getInputStream()));
+                        timestamp = System.currentTimeMillis();
             metadata = tr("requested: {0}", tr(in.readLine()));
         }
@@ -94 +114 @@
             metadata = tr("error requesting update");
         }
+    }
+
+    public long access_time()
+    {
+        return timestamp;
     }