+ *
+ */
+public class TMSKey {
+ private final int x;
+ private final int y;
+ private final int level;
+
+ /**
+ *
+ * Constructs key for hashmaps for some tile describedy by X and Y position. X and Y are tiles
+ * positions on discrete map.
+ *
+ *
+ * @param x x position in tiles table
+ * @param y y position in tiles table
+ */
+ public final boolean valid;
+ public TMSKey(int x, int y, int level) {
+ this.x = x;
+ this.y = y;
+ this.level = level;
+ if (level <= 0 || x < 0 || y < 0) {
+ this.valid = false;
+ System.err.println("invalid TMSKey("+level+", "+x+", "+y+")");
+ } else {
+ this.valid = true;
+ }
+ }
+
+ /**
+ *
+ * Returns true ONLY if x and y are equals.
+ *
+ *
+ * @see java.lang.Object#equals(java.lang.Object)
+ */
+ @Override
+ public boolean equals(Object obj) {
+ if (obj instanceof TMSKey) {
+ TMSKey smk = (TMSKey) obj;
+ if((smk.x == this.x) && (smk.y == this.y) && (smk.level == this.level)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * @return return new Integer(this.x + this.y * 10000).hashCode();
+ * @see java.lang.Object#hashCode()
+ */
+ @Override
+ public int hashCode() {
+ return new Integer(this.x + this.y * 10000 + this.level * 100000).hashCode();
+ }
+
+ /**
+ * @see java.lang.Object#toString()
+ */
+ @Override
+ public String toString() {
+ return "TMSKey(x=" + this.x + ",y=" + this.y + ",level=" + level + ")";
+ }
+
+}
Index: applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/tms/TMSLayer.java
===================================================================
--- applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/tms/TMSLayer.java (revision 24501)
+++ applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/tms/TMSLayer.java (revision 24501)
@@ -0,0 +1,1073 @@
+package org.openstreetmap.josm.plugins.imagery.tms;
+
+import static org.openstreetmap.josm.tools.I18n.tr;
+
+import java.awt.Color;
+import java.awt.Font;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.Image;
+import java.awt.Point;
+import java.awt.Rectangle;
+import java.awt.Toolkit;
+import java.awt.event.ActionEvent;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.awt.geom.Rectangle2D;
+import java.awt.image.ImageObserver;
+import java.io.IOException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+
+import javax.swing.AbstractAction;
+import javax.swing.Action;
+import javax.swing.JCheckBoxMenuItem;
+import javax.swing.JMenuItem;
+import javax.swing.JPopupMenu;
+import javax.swing.SwingUtilities;
+
+import org.openstreetmap.gui.jmapviewer.JobDispatcher;
+import org.openstreetmap.gui.jmapviewer.MemoryTileCache;
+import org.openstreetmap.gui.jmapviewer.OsmFileCacheTileLoader;
+import org.openstreetmap.gui.jmapviewer.Tile;
+import org.openstreetmap.gui.jmapviewer.interfaces.TileCache;
+import org.openstreetmap.gui.jmapviewer.interfaces.TileLoader;
+import org.openstreetmap.gui.jmapviewer.interfaces.TileLoaderListener;
+import org.openstreetmap.gui.jmapviewer.interfaces.TileSource;
+import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.actions.RenameLayerAction;
+import org.openstreetmap.josm.data.Bounds;
+import org.openstreetmap.josm.data.coor.LatLon;
+import org.openstreetmap.josm.data.osm.visitor.BoundingXYVisitor;
+import org.openstreetmap.josm.gui.MapView;
+import org.openstreetmap.josm.gui.MapView.LayerChangeListener;
+import org.openstreetmap.josm.gui.dialogs.LayerListDialog;
+import org.openstreetmap.josm.gui.dialogs.LayerListPopup;
+import org.openstreetmap.josm.gui.layer.Layer;
+import org.openstreetmap.josm.plugins.imagery.ImageryInfo;
+import org.openstreetmap.josm.plugins.imagery.ImageryInfo.ImageryType;
+import org.openstreetmap.josm.plugins.imagery.ImageryLayer;
+
+/**
+ * Class that displays a slippy map layer.
+ *
+ * @author Frederik Ramm
+ * @author LuVar
+ * @author Dave Hansen
+ *
+ */
+public class TMSLayer extends ImageryLayer implements ImageObserver, TileLoaderListener {
+ boolean debug = false;
+ void out(String s)
+ {
+ Main.debug(s);
+ }
+
+ protected MemoryTileCache tileCache;
+ protected TileSource tileSource;
+ protected TileLoader tileLoader;
+ JobDispatcher jobDispatcher = JobDispatcher.getInstance();
+
+ HashSet tileRequestsOutstanding = new HashSet();
+ @Override
+ public synchronized void tileLoadingFinished(Tile tile, boolean success)
+ {
+ tile.setLoaded(true);
+ needRedraw = true;
+ Main.map.repaint(100);
+ tileRequestsOutstanding.remove(tile);
+ if (debug)
+ out("tileLoadingFinished() tile: " + tile + " success: " + success);
+ }
+ @Override
+ public TileCache getTileCache()
+ {
+ return tileCache;
+ }
+ void clearTileCache()
+ {
+ if (debug)
+ out("clearing tile storage");
+ tileCache = new MemoryTileCache();
+ tileCache.setCacheSize(200);
+ }
+
+ /**
+ * Actual zoom lvl. Initial zoom lvl is set to
+ */
+ public int currentZoomLevel;
+
+ LatLon lastTopLeft;
+ LatLon lastBotRight;
+ private Image bufferImage;
+ private Tile clickedTile;
+ private boolean needRedraw;
+ private JPopupMenu tileOptionMenu;
+ JCheckBoxMenuItem autoZoomPopup;
+ Tile showMetadataTile;
+ private Image attrImage;
+ private String attrTermsUrl;
+ private Rectangle attrImageBounds, attrToUBounds;
+ private static Font ATTR_FONT = Font.decode("Arial 10");
+ private static Font ATTR_LINK_FONT = Font.decode("Arial Underline 10");
+
+ protected boolean autoZoom = true;
+ protected boolean autoLoad = true;
+
+ void redraw()
+ {
+ needRedraw = true;
+ Main.map.repaint();
+ }
+
+ private void setTileStorage(TileSource tileSource)
+ {
+ int origZoom = currentZoomLevel;
+ this.tileSource = tileSource;
+ boolean requireAttr = tileSource.requiresAttribution();
+ if(requireAttr) {
+ attrImage = tileSource.getAttributionImage();
+ if(attrImage == null) {
+ System.out.println("Attribution image was null.");
+ } else {
+ System.out.println("Got an attribution image " + attrImage.getHeight(this) + "x" + attrImage.getWidth(this));
+ }
+
+ attrTermsUrl = tileSource.getTermsOfUseURL();
+ }
+
+ // The minimum should also take care of integer parsing
+ // errors which would leave us with a zoom of -1 otherwise
+ if (tileSource.getMaxZoom() < currentZoomLevel)
+ currentZoomLevel = tileSource.getMaxZoom();
+ if (tileSource.getMinZoom() > currentZoomLevel)
+ currentZoomLevel = tileSource.getMinZoom();
+ if (currentZoomLevel != origZoom) {
+ out("changed currentZoomLevel loading new tile store from " + origZoom + " to " + currentZoomLevel);
+ out("tileSource.getMinZoom(): " + tileSource.getMinZoom());
+ out("tileSource.getMaxZoom(): " + tileSource.getMaxZoom());
+ }
+ clearTileCache();
+ //tileloader = new OsmTileLoader(this);
+ tileLoader = new OsmFileCacheTileLoader(this);
+ }
+
+ @Override
+ public void displace(double dx, double dy) {
+ super.displace(dx, dy);
+ needRedraw = true;
+ }
+
+ @SuppressWarnings("serial")
+ public TMSLayer(ImageryInfo info) {
+ super(info.getName());
+
+ setBackgroundLayer(true);
+ this.setVisible(true);
+
+ currentZoomLevel = 0; //FIXME: detect current zoom level
+ if (info.getImageryType() == ImageryType.TMS) {
+ setTileStorage(new TMSTileSource(info.getName(),info.getURL()));
+ } else if (info.getImageryType() == ImageryType.BING) {
+ setTileStorage(new BingAerialTileSource());
+ } else throw new AssertionError();
+
+ tileOptionMenu = new JPopupMenu();
+
+ autoZoomPopup = new JCheckBoxMenuItem();
+ autoZoomPopup.setAction(new AbstractAction(tr("Auto Zoom")) {
+ @Override
+ public void actionPerformed(ActionEvent ae) {
+ autoZoom = !autoZoom;
+ }
+ });
+ autoZoomPopup.setSelected(autoZoom);
+ tileOptionMenu.add(autoZoomPopup);
+
+ tileOptionMenu.add(new JMenuItem(new AbstractAction(tr("Load Tile")) {
+ @Override
+ public void actionPerformed(ActionEvent ae) {
+ if (clickedTile != null) {
+ loadTile(clickedTile);
+ redraw();
+ }
+ }
+ }));
+
+ tileOptionMenu.add(new JMenuItem(new AbstractAction(
+ tr("Show Tile Info")) {
+ @Override
+ public void actionPerformed(ActionEvent ae) {
+ out("info tile: " + clickedTile);
+ if (clickedTile != null) {
+ showMetadataTile = clickedTile;
+ redraw();
+ }
+ }
+ }));
+
+ /* FIXME
+ tileOptionMenu.add(new JMenuItem(new AbstractAction(
+ tr("Request Update")) {
+ public void actionPerformed(ActionEvent ae) {
+ if (clickedTile != null) {
+ clickedTile.requestUpdate();
+ redraw();
+ }
+ }
+ }));*/
+
+ tileOptionMenu.add(new JMenuItem(new AbstractAction(
+ tr("Load All Tiles")) {
+ @Override
+ public void actionPerformed(ActionEvent ae) {
+ loadAllTiles(true);
+ redraw();
+ }
+ }));
+
+ // increase and decrease commands
+ tileOptionMenu.add(new JMenuItem(
+ new AbstractAction(tr("Increase zoom")) {
+ @Override
+ public void actionPerformed(ActionEvent ae) {
+ increaseZoomLevel();
+ redraw();
+ }
+ }));
+
+ tileOptionMenu.add(new JMenuItem(
+ new AbstractAction(tr("Decrease zoom")) {
+ @Override
+ public void actionPerformed(ActionEvent ae) {
+ decreaseZoomLevel();
+ redraw();
+ }
+ }));
+
+ // FIXME: currently ran in errors
+
+ tileOptionMenu.add(new JMenuItem(
+ new AbstractAction(tr("Snap to tile size")) {
+ @Override
+ public void actionPerformed(ActionEvent ae) {
+ if (lastImageScale == null) {
+ out("please wait for a tile to be loaded before snapping");
+ return;
+ }
+ double new_factor = Math.sqrt(lastImageScale);
+ if (debug)
+ out("tile snap: scale was: " + lastImageScale + ", new factor: " + new_factor);
+ Main.map.mapView.zoomToFactor(new_factor);
+ redraw();
+ }
+ }));
+ // end of adding menu commands
+
+ tileOptionMenu.add(new JMenuItem(
+ new AbstractAction(tr("Flush Tile Cache")) {
+ @Override
+ public void actionPerformed(ActionEvent ae) {
+ System.out.print("flushing all tiles...");
+ clearTileCache();
+ System.out.println("done");
+ }
+ }));
+ // end of adding menu commands
+
+ SwingUtilities.invokeLater(new Runnable() {
+ @Override
+ public void run() {
+ Main.map.mapView.addMouseListener(new MouseAdapter() {
+ @Override
+ public void mouseClicked(MouseEvent e) {
+ if (e.getButton() == MouseEvent.BUTTON3) {
+ clickedTile = getTileForPixelpos(e.getX(), e.getY());
+ tileOptionMenu.show(e.getComponent(), e.getX(), e.getY());
+ } else if (e.getButton() == MouseEvent.BUTTON1) {
+ if(!tileSource.requiresAttribution()) {
+ return;
+ }
+
+ if(attrImageBounds.contains(e.getPoint())) {
+ try {
+ java.awt.Desktop desktop = java.awt.Desktop.getDesktop();
+ desktop.browse(new URI(tileSource.getAttributionLinkURL()));
+ } catch (IOException e1) {
+ e1.printStackTrace();
+ } catch (URISyntaxException e1) {
+ e1.printStackTrace();
+ }
+ } else if(attrToUBounds.contains(e.getPoint())) {
+ try {
+ java.awt.Desktop desktop = java.awt.Desktop.getDesktop();
+ desktop.browse(new URI(tileSource.getTermsOfUseURL()));
+ } catch (IOException e1) {
+ e1.printStackTrace();
+ } catch (URISyntaxException e1) {
+ e1.printStackTrace();
+ }
+ }
+ }
+ }
+ });
+
+ MapView.addLayerChangeListener(new LayerChangeListener() {
+ @Override
+ public void activeLayerChange(Layer oldLayer, Layer newLayer) {
+ //
+ }
+
+ @Override
+ public void layerAdded(Layer newLayer) {
+ //
+ }
+
+ @Override
+ public void layerRemoved(Layer oldLayer) {
+ MapView.removeLayerChangeListener(this);
+ }
+ });
+ }
+ });
+ }
+
+ void zoomChanged()
+ {
+ if (debug)
+ out("zoomChanged(): " + currentZoomLevel);
+ needRedraw = true;
+ jobDispatcher.cancelOutstandingJobs();
+ tileRequestsOutstanding.clear();
+ }
+
+ int getMaxZoomLvl()
+ {
+ return tileSource.getMaxZoom();
+ }
+
+ int getMinZoomLvl()
+ {
+ return tileSource.getMinZoom();
+ }
+
+ /**
+ * Zoom in, go closer to map.
+ *
+ * @return true, if zoom increasing was successfull, false othervise
+ */
+ public boolean zoomIncreaseAllowed()
+ {
+ boolean zia = currentZoomLevel < this.getMaxZoomLvl();
+ if (debug)
+ out("zoomIncreaseAllowed(): " + zia + " " + currentZoomLevel + " vs. " + this.getMaxZoomLvl() );
+ return zia;
+ }
+ public boolean increaseZoomLevel()
+ {
+ lastImageScale = null;
+ if (zoomIncreaseAllowed()) {
+ currentZoomLevel++;
+ if (debug)
+ out("increasing zoom level to: " + currentZoomLevel);
+ zoomChanged();
+ } else {
+ System.err.println("current zoom lvl ("+currentZoomLevel+") couldnt be increased. "+
+ "MaxZoomLvl ("+this.getMaxZoomLvl()+") reached.");
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * Zoom out from map.
+ *
+ * @return true, if zoom increasing was successfull, false othervise
+ */
+ public boolean zoomDecreaseAllowed()
+ {
+ return currentZoomLevel > this.getMinZoomLvl();
+ }
+ public boolean decreaseZoomLevel() {
+ int minZoom = this.getMinZoomLvl();
+ lastImageScale = null;
+ if (zoomDecreaseAllowed()) {
+ if (debug)
+ out("decreasing zoom level to: " + currentZoomLevel);
+ currentZoomLevel--;
+ zoomChanged();
+ } else {
+ System.err.println("current zoom lvl couldnt be decreased. MinZoomLvl("+minZoom+") reached.");
+ return false;
+ }
+ return true;
+ }
+
+ /*
+ * We use these for quick, hackish calculations. They
+ * are temporary only and intentionally not inserted
+ * into the tileCache.
+ */
+ synchronized Tile tempCornerTile(Tile t) {
+ int x = t.getXtile() + 1;
+ int y = t.getYtile() + 1;
+ int zoom = t.getZoom();
+ Tile tile = getTile(x, y, zoom);
+ if (tile != null)
+ return tile;
+ return new Tile(tileSource, x, y, zoom);
+ }
+ synchronized Tile getOrCreateTile(int x, int y, int zoom) {
+ Tile tile = getTile(x, y, zoom);
+ if (tile == null) {
+ tile = new Tile(tileSource, x, y, zoom);
+ tileCache.addTile(tile);
+ tile.loadPlaceholderFromCache(tileCache);
+ }
+ return tile;
+ }
+
+ /*
+ * This can and will return null for tiles that are not
+ * already in the cache.
+ */
+ synchronized Tile getTile(int x, int y, int zoom) {
+ int max = (1 << zoom);
+ if (x < 0 || x >= max || y < 0 || y >= max)
+ return null;
+ Tile tile = tileCache.getTile(tileSource, x, y, zoom);
+ return tile;
+ }
+
+ synchronized boolean loadTile(Tile tile)
+ {
+ if (tile == null)
+ return false;
+ if (tile.hasError())
+ return false;
+ if (tile.isLoaded())
+ return false;
+ if (tile.isLoading())
+ return false;
+ if (tileRequestsOutstanding.contains(tile))
+ return false;
+ tileRequestsOutstanding.add(tile);
+ jobDispatcher.addJob(tileLoader.createTileLoaderJob(tileSource,
+ tile.getXtile(), tile.getYtile(), tile.getZoom()));
+ return true;
+ }
+
+ void loadAllTiles(boolean force) {
+ MapView mv = Main.map.mapView;
+ LatLon topLeft = mv.getLatLon(0, 0);
+ LatLon botRight = mv.getLatLon(mv.getWidth(), mv.getHeight());
+
+ TileSet ts = new TileSet(topLeft, botRight, currentZoomLevel);
+
+ // if there is more than 18 tiles on screen in any direction, do not
+ // load all tiles!
+ if (ts.tooLarge()) {
+ System.out.println("Not downloading all tiles because there is more than 18 tiles on an axis!");
+ return;
+ }
+ ts.loadAllTiles(force);
+ }
+
+ /*
+ * Attempt to approximate how much the image is being scaled. For instance,
+ * a 100x100 image being scaled to 50x50 would return 0.25.
+ */
+ Image lastScaledImage = null;
+ @Override
+ public boolean imageUpdate(Image img, int infoflags, int x, int y, int width, int height) {
+ boolean done = ((infoflags & (ERROR | FRAMEBITS | ALLBITS)) != 0);
+ needRedraw = true;
+ if (debug)
+ out("imageUpdate() done: " + done + " calling repaint");
+ Main.map.repaint(done ? 0 : 100);
+ return !done;
+ }
+ boolean imageLoaded(Image i) {
+ if (i == null)
+ return false;
+ int status = Toolkit.getDefaultToolkit().checkImage(i, -1, -1, this);
+ if ((status & ALLBITS) != 0)
+ return true;
+ return false;
+ }
+ Image getLoadedTileImage(Tile tile)
+ {
+ if (!tile.isLoaded())
+ return null;
+ Image img = tile.getImage();
+ if (!imageLoaded(img))
+ return null;
+ return img;
+ }
+
+ double getImageScaling(Image img, Rectangle r) {
+ int realWidth = -1;
+ int realHeight = -1;
+ if (img != null) {
+ realWidth = img.getHeight(this);
+ realWidth = img.getWidth(this);
+ }
+ if (realWidth == -1 || realHeight == -1) {
+ /*
+ * We need a good image against which to work. If
+ * the current one isn't loaded, then try the last one.
+ * Should be good enough. If we've never seen one, then
+ * guess.
+ */
+ if (lastScaledImage != null) {
+ return getImageScaling(lastScaledImage, r);
+ }
+ realWidth = 256;
+ realHeight = 256;
+ } else {
+ lastScaledImage = img;
+ }
+ /*
+ * If the zoom scale gets really, really off, these can get into
+ * the millions, so make this a double to prevent integer
+ * overflows.
+ */
+ double drawWidth = r.width;
+ double drawHeight = r.height;
+ // stem.out.println("drawWidth: " + drawWidth + " drawHeight: " +
+ // drawHeight);
+
+ double drawArea = drawWidth * drawHeight;
+ double realArea = realWidth * realHeight;
+
+ return drawArea / realArea;
+ }
+
+ LatLon tileLatLon(Tile t)
+ {
+ int zoom = t.getZoom();
+ return new LatLon(tileYToLat(t.getYtile(), zoom),
+ tileXToLon(t.getXtile(), zoom));
+ }
+
+ int paintFromOtherZooms(Graphics g, Tile topLeftTile, Tile botRightTile)
+ {
+ LatLon topLeft = tileLatLon(topLeftTile);
+ LatLon botRight = tileLatLon(botRightTile);
+
+
+ /*
+ * Go looking for tiles in zoom levels *other* than the current
+ * one. Even if they might look bad, they look better than a
+ * blank tile.
+ *
+ * Make darn sure that the tilesCache can either hold all of
+ * these "fake" tiles or that they don't get inserted in it to
+ * begin with.
+ */
+ //int otherZooms[] = {-5, -4, -3, 2, -2, 1, -1};
+ int otherZooms[] = { -1, 1, -2, 2, -3, -4, -5};
+ int painted = 0;
+ debug = true;
+ for (int zoomOff : otherZooms) {
+ int zoom = currentZoomLevel + zoomOff;
+ if ((zoom < this.getMinZoomLvl()) ||
+ (zoom > this.getMaxZoomLvl())) {
+ continue;
+ }
+ TileSet ts = new TileSet(topLeft, botRight, zoom);
+ int zoom_painted = 0;
+ this.paintTileImages(g, ts, zoom, null);
+ if (debug && zoom_painted > 0)
+ out("painted " + zoom_painted + "/"+ ts.size() +
+ " tiles from zoom("+zoomOff+"): " + zoom);
+ painted += zoom_painted;
+ if (zoom_painted >= ts.size()) {
+ if (debug)
+ out("broke after drawing " + zoom_painted + "/"+ ts.size() + " at zoomOff: " + zoomOff);
+ break;
+ }
+ }
+ debug = false;
+ return painted;
+ }
+ Rectangle tileToRect(Tile t1)
+ {
+ /*
+ * We need to get a box in which to draw, so advance by one tile in
+ * each direction to find the other corner of the box.
+ * Note: this somewhat pollutes the tile cache
+ */
+ Tile t2 = tempCornerTile(t1);
+ Rectangle rect = new Rectangle(pixelPos(t1));
+ rect.add(pixelPos(t2));
+ return rect;
+ }
+
+ // 'source' is the pixel coordinates for the area that
+ // the img is capable of filling in. However, we probably
+ // only want a portion of it.
+ //
+ // 'border' is the screen cordinates that need to be drawn.
+ // We must not draw outside of it.
+ void drawImageInside(Graphics g, Image sourceImg, Rectangle source, Rectangle border)
+ {
+ Rectangle target = source;
+
+ // If a border is specified, only draw the intersection
+ // if what we have combined with what we are supposed
+ // to draw.
+ if (border != null) {
+ target = source.intersection(border);
+ if (debug)
+ out("source: " + source + "\nborder: " + border + "\nintersection: " + target);
+ }
+
+ // All of the rectangles are in screen coordinates. We need
+ // to how these correlate to the sourceImg pixels. We could
+ // avoid doing this by scaling the image up to the 'source' size,
+ // but this should be cheaper.
+ //
+ // In some projections, x any y are scaled differently enough to
+ // cause a pixel or two of fudge. Calculate them separately.
+ double imageYScaling = sourceImg.getHeight(this) / source.getHeight();
+ double imageXScaling = sourceImg.getWidth(this) / source.getWidth();
+
+ // How many pixels into the 'source' rectangle are we drawing?
+ int screen_x_offset = target.x - source.x;
+ int screen_y_offset = target.y - source.y;
+ // And how many pixels into the image itself does that
+ // correlate to?
+ int img_x_offset = (int)(screen_x_offset * imageXScaling);
+ int img_y_offset = (int)(screen_y_offset * imageYScaling);
+ // Now calculate the other corner of the image that we need
+ // by scaling the 'target' rectangle's dimensions.
+ int img_x_end = img_x_offset + (int)(target.getWidth() * imageXScaling);
+ int img_y_end = img_y_offset + (int)(target.getHeight() * imageYScaling);
+
+ if (debug) {
+ out("drawing image into target rect: " + target);
+ }
+ g.drawImage(sourceImg,
+ target.x, target.y,
+ target.x + target.width, target.y + target.height,
+ img_x_offset, img_y_offset,
+ img_x_end, img_y_end,
+ this);
+ }
+ Double lastImageScale = null;
+ // This function is called for several zoom levels, not just
+ // the current one. It should not trigger any tiles to be
+ // downloaded. It should also avoid polluting the tile cache
+ // with any tiles since these tiles are not mandatory.
+ //
+ // The "border" tile tells us the boundaries of where we may
+ // draw. It will not be from the zoom level that is being
+ // drawn currently. If drawing the currentZoomLevel,
+ // border is null and we draw the entire tile set.
+ List paintTileImages(Graphics g, TileSet ts, int zoom, Tile border) {
+ Rectangle borderRect = null;
+ if (border != null)
+ borderRect = tileToRect(border);
+ List missedTiles = new LinkedList();
+ boolean imageScaleRecorded = false;
+ for (Tile tile : ts.allTiles()) {
+ Image img = getLoadedTileImage(tile);
+ if (img == null) {
+ if (debug)
+ out("missed tile: " + tile);
+ missedTiles.add(tile);
+ continue;
+ }
+ Rectangle sourceRect = tileToRect(tile);
+ if (borderRect != null && !sourceRect.intersects(borderRect))
+ continue;
+ drawImageInside(g, img, sourceRect, borderRect);
+ if (!imageScaleRecorded && zoom == currentZoomLevel) {
+ lastImageScale = new Double(getImageScaling(img, sourceRect));
+ imageScaleRecorded = true;
+ }
+ }// end of for
+ return missedTiles;
+ }
+
+ void paintTileText(TileSet ts, Tile tile, Graphics g, MapView mv, int zoom, Tile t) {
+ int fontHeight = g.getFontMetrics().getHeight();
+ if (tile == null)
+ return;
+ Point p = pixelPos(t);
+ int texty = p.y + 2 + fontHeight;
+
+ if (tile == showMetadataTile) {
+ String md = tile.toString();
+ if (md != null) {
+ g.drawString(md, p.x + 2, texty);
+ texty += 1 + fontHeight;
+ }
+ }
+
+ String tileStatus = tile.getStatus();
+ if (!tile.isLoaded()) {
+ g.drawString(tr("image " + tileStatus), p.x + 2, texty);
+ texty += 1 + fontHeight;
+ }
+ }
+
+ public Point pixelPos(LatLon ll) {
+ return Main.map.mapView.getPoint(Main.proj.latlon2eastNorth(ll).add(getDx(), getDy()));
+ }
+ public Point pixelPos(Tile t) {
+ double lon = tileXToLon(t.getXtile(), t.getZoom());
+ LatLon tmpLL = new LatLon(tileYToLat(t.getYtile(), t.getZoom()), lon);
+ return pixelPos(tmpLL);
+ }
+ private class TileSet {
+ int z12x0, z12x1, z12y0, z12y1;
+ int zoom;
+ int tileMax = -1;
+
+ TileSet(LatLon topLeft, LatLon botRight, int zoom) {
+ this.zoom = zoom;
+ z12x0 = lonToTileX(topLeft.lon(), zoom);
+ z12y0 = latToTileY(topLeft.lat(), zoom);
+ z12x1 = lonToTileX(botRight.lon(), zoom);
+ z12y1 = latToTileY(botRight.lat(), zoom);
+ if (z12x0 > z12x1) {
+ int tmp = z12x0;
+ z12x0 = z12x1;
+ z12x1 = tmp;
+ }
+ if (z12y0 > z12y1) {
+ int tmp = z12y0;
+ z12y0 = z12y1;
+ z12y1 = tmp;
+ }
+ tileMax = (int)Math.pow(2.0, zoom);
+ if (z12x0 < 0) z12x0 = 0;
+ if (z12y0 < 0) z12y0 = 0;
+ if (z12x1 > tileMax) z12x1 = tileMax;
+ if (z12y1 > tileMax) z12y1 = tileMax;
+ }
+ boolean tooSmall() {
+ return this.tilesSpanned() < 2.1;
+ }
+ boolean tooLarge() {
+ return this.tilesSpanned() > 10;
+ }
+ boolean insane() {
+ return this.tilesSpanned() > 100;
+ }
+ double tilesSpanned() {
+ return Math.sqrt(1.0 * this.size());
+ }
+
+ double size() {
+ double x_span = z12x1 - z12x0 + 1.0;
+ double y_span = z12y1 - z12y0 + 1.0;
+ return x_span * y_span;
+ }
+
+ /*
+ * Get all tiles represented by this TileSet that are
+ * already in the tileCache.
+ */
+ List allTiles()
+ {
+ return this.allTiles(false);
+ }
+ private List allTiles(boolean create)
+ {
+ List ret = new ArrayList();
+ // Don't even try to iterate over the set.
+ // Someone created a crazy number of them
+ if (this.insane())
+ return ret;
+ for (int x = z12x0; x <= z12x1; x++) {
+ for (int y = z12y0; y <= z12y1; y++) {
+ Tile t;
+ if (create)
+ t = getOrCreateTile(x % tileMax, y % tileMax, zoom);
+ else
+ t = getTile(x % tileMax, y % tileMax, zoom);
+ if (t != null)
+ ret.add(t);
+ }
+ }
+ return ret;
+ }
+ void loadAllTiles(boolean force)
+ {
+ List tiles = this.allTiles(true);
+ boolean autoload = TMSLayer.this.autoLoad;
+ if (!autoload && !force)
+ return;
+ int nr_queued = 0;
+ for (Tile t : tiles) {
+ if (loadTile(t))
+ nr_queued++;
+ }
+ if (debug)
+ if (nr_queued > 0)
+ out("queued to load: " + nr_queued + "/" + tiles.size() + " tiles at zoom: " + zoom);
+ }
+ }
+
+ boolean az_disable = false;
+ boolean autoZoomEnabled()
+ {
+ if (az_disable)
+ return false;
+ return autoZoom;
+ }
+ /**
+ */
+ @Override
+ public void paint(Graphics2D g, MapView mv, Bounds bounds) {
+ //long start = System.currentTimeMillis();
+ LatLon topLeft = mv.getLatLon(0, 0);
+ LatLon botRight = mv.getLatLon(mv.getWidth(), mv.getHeight());
+ Graphics2D oldg = g;
+
+ if (botRight.lon() == 0.0 || botRight.lat() == 0) {
+ Main.debug("still initializing??");
+ // probably still initializing
+ return;
+ }
+
+ if (lastTopLeft != null && lastBotRight != null && topLeft.equalsEpsilon(lastTopLeft)
+ && botRight.equalsEpsilon(lastBotRight) && bufferImage != null
+ && mv.getWidth() == bufferImage.getWidth(null) && mv.getHeight() == bufferImage.getHeight(null)
+ && !needRedraw) {
+
+ if (debug)
+ out("drawing buffered image");
+ g.drawImage(bufferImage, 0, 0, null);
+ return;
+ }
+
+ needRedraw = false;
+ lastTopLeft = topLeft;
+ lastBotRight = botRight;
+ bufferImage = mv.createImage(mv.getWidth(), mv.getHeight());
+ g = (Graphics2D) bufferImage.getGraphics();
+
+ int zoom = currentZoomLevel;
+ TileSet ts = new TileSet(topLeft, botRight, zoom);
+
+ if (autoZoomEnabled()) {
+ if (zoomDecreaseAllowed() && ts.tooLarge()) {
+ if (debug)
+ out("too many tiles, decreasing zoom from " + currentZoomLevel);
+ if (decreaseZoomLevel())
+ this.paint(oldg, mv, bounds);
+ return;
+ }
+ if (zoomIncreaseAllowed() && ts.tooSmall()) {
+ if (debug)
+ out("too zoomed in, (" + ts.tilesSpanned()
+ + "), increasing zoom from " + currentZoomLevel);
+ // This is a hack. ts.tooSmall() is proabably a bad thing, and this works
+ // around it. If we have a very small window, the tileSet may be well
+ // less than 1 real tile wide, but that's expected. But, this sees the
+ // tile set as too small and zooms in. The code below that checks for
+ // pixel stretching disagrees and tries to zoom out. Both calls recurse,
+ // hillarity ensues, and the stack overflows.
+ //
+ // This really needs to get fixed properly. We probably shouldn't even
+ // have the tooSmall() check on tileSets. But, this also helps the zoom
+ // converge to the correct place much faster.
+ boolean tmp = az_disable;
+ az_disable = true;
+ if (increaseZoomLevel())
+ this.paint(oldg, mv, bounds);
+ az_disable = tmp;
+ return;
+ }
+ }
+
+ // Too many tiles... refuse to draw
+ if (!ts.tooLarge()) {
+ //out("size: " + ts.size() + " spanned: " + ts.tilesSpanned());
+ ts.loadAllTiles(false);
+ }
+
+ g.setColor(Color.DARK_GRAY);
+
+ List missedTiles = this.paintTileImages(g, ts, currentZoomLevel, null);
+ int otherZooms[] = { -1, 1, -2, 2, -3, -4, -5};
+ for (int zoomOffset : otherZooms) {
+ if (!autoZoomEnabled())
+ break;
+ if (!autoLoad)
+ break;
+ int newzoom = currentZoomLevel + zoomOffset;
+ if (missedTiles.size() <= 0)
+ break;
+ List newlyMissedTiles = new LinkedList();
+ for (Tile missed : missedTiles) {
+ Tile t2 = tempCornerTile(missed);
+ LatLon topLeft2 = tileLatLon(missed);
+ LatLon botRight2 = tileLatLon(t2);
+ TileSet ts2 = new TileSet(topLeft2, botRight2, newzoom);
+ if (ts2.tooLarge())
+ continue;
+ newlyMissedTiles.addAll(this.paintTileImages(g, ts2, newzoom, missed));
+ }
+ missedTiles = newlyMissedTiles;
+ }
+ if (debug && missedTiles.size() > 0) {
+ out("still missed "+missedTiles.size()+" in the end");
+ }
+ g.setColor(Color.red);
+
+ // The current zoom tileset is guaranteed to have all of
+ // its tiles
+ for (Tile t : ts.allTiles()) {
+ this.paintTileText(ts, t, g, mv, currentZoomLevel, t);
+ }
+
+ if (tileSource.requiresAttribution()) {
+ // Draw attribution
+ g.setColor(Color.white);
+ Font font = g.getFont();
+ g.setFont(ATTR_LINK_FONT);
+
+ // Draw terms of use text
+ Rectangle2D termsStringBounds = g.getFontMetrics().getStringBounds("Background Terms of Use", g);
+ int textHeight = (int) termsStringBounds.getHeight() - 5;
+ int textWidth = (int) termsStringBounds.getWidth();
+ int termsTextY = mv.getHeight() - textHeight;
+ if(attrTermsUrl != null) {
+ int x = 2;
+ int y = mv.getHeight() - textHeight;
+ attrToUBounds = new Rectangle(x, y, textWidth, textHeight);
+ g.drawString("Background Terms of Use", x, y);
+ }
+
+ // Draw attribution logo
+ int imgWidth = attrImage.getWidth(this);
+ if(attrImage != null) {
+ int x = 2;
+ int height = attrImage.getHeight(this);
+ int y = termsTextY - height;
+ attrImageBounds = new Rectangle(x, y, imgWidth, height);
+ g.drawImage(attrImage, x, y, this);
+ }
+
+ String attributionText = tileSource.getAttributionText(currentZoomLevel, topLeft, botRight);
+ Rectangle2D stringBounds = g.getFontMetrics().getStringBounds(attributionText, g);
+ g.drawString(attributionText, mv.getWidth() - (int) stringBounds.getWidth(), mv.getHeight() - textHeight);
+
+ g.setFont(font);
+ }
+
+ oldg.drawImage(bufferImage, 0, 0, null);
+
+ if (autoZoomEnabled() && lastImageScale != null) {
+ // If each source image pixel is being stretched into > 3
+ // drawn pixels, zoom in... getting too pixelated
+ if (lastImageScale > 3 && zoomIncreaseAllowed()) {
+ if (debug)
+ out("autozoom increase: scale: " + lastImageScale);
+ increaseZoomLevel();
+ this.paint(oldg, mv, bounds);
+ // If each source image pixel is being squished into > 0.32
+ // of a drawn pixels, zoom out.
+ } else if ((lastImageScale < 0.45) && (lastImageScale > 0) && zoomDecreaseAllowed()) {
+ if (debug)
+ out("autozoom decrease: scale: " + lastImageScale);
+ decreaseZoomLevel();
+ this.paint(oldg, mv, bounds);
+ }
+ }
+ //g.drawString("currentZoomLevel=" + currentZoomLevel, 120, 120);
+ oldg.setColor(Color.black);
+ if (ts.insane()) {
+ oldg.drawString("zoom in to load any tiles", 120, 120);
+ } else if (ts.tooLarge()) {
+ oldg.drawString("zoom in to load more tiles", 120, 120);
+ } else if (ts.tooSmall()) {
+ oldg.drawString("increase zoom level to see more detail", 120, 120);
+ }
+ }// end of paint method
+
+ /**
+ * This isn't very efficient, but it is only used when the
+ * user right-clicks on the map.
+ */
+ Tile getTileForPixelpos(int px, int py) {
+ if (debug)
+ out("getTileForPixelpos("+px+", "+py+")");
+ MapView mv = Main.map.mapView;
+ Point clicked = new Point(px, py);
+ LatLon topLeft = mv.getLatLon(0, 0);
+ LatLon botRight = mv.getLatLon(mv.getWidth(), mv.getHeight());
+ int z = currentZoomLevel;
+ TileSet ts = new TileSet(topLeft, botRight, z);
+
+ if (!ts.tooLarge())
+ ts.loadAllTiles(false); // make sure there are tile objects for all tiles
+ Tile clickedTile = null;
+ for (Tile t1 : ts.allTiles()) {
+ Tile t2 = tempCornerTile(t1);
+ Rectangle r = new Rectangle(pixelPos(t1));
+ r.add(pixelPos(t2));
+ if (debug)
+ out("r: " + r + " clicked: " + clicked);
+ if (!r.contains(clicked))
+ continue;
+ clickedTile = t1;
+ break;
+ }
+ if (clickedTile == null)
+ return null;
+ System.out.println("clicked on tile: " + clickedTile.getXtile() + " " + clickedTile.getYtile() +
+ " scale: " + lastImageScale + " currentZoomLevel: " + currentZoomLevel);
+ return clickedTile;
+ }
+
+ @Override
+ public Action[] getMenuEntries() {
+ return new Action[] {
+ LayerListDialog.getInstance().createShowHideLayerAction(),
+ LayerListDialog.getInstance().createDeleteLayerAction(),
+ SeparatorLayerAction.INSTANCE,
+ // color,
+ new RenameLayerAction(this.getAssociatedFile(), this),
+ SeparatorLayerAction.INSTANCE,
+ new LayerListPopup.InfoAction(this) };
+ }
+
+ @Override
+ public String getToolTipText() {
+ return null;
+ }
+
+ @Override
+ public void visitBoundingBox(BoundingXYVisitor v) {
+ }
+
+ private int latToTileY(double lat, int zoom) {
+ double l = lat / 180 * Math.PI;
+ double pf = Math.log(Math.tan(l) + (1 / Math.cos(l)));
+ return (int) (Math.pow(2.0, zoom - 1) * (Math.PI - pf) / Math.PI);
+ }
+
+ private int lonToTileX(double lon, int zoom) {
+ return (int) (Math.pow(2.0, zoom - 3) * (lon + 180.0) / 45.0);
+ }
+
+ private double tileYToLat(int y, int zoom) {
+ return Math.atan(Math.sinh(Math.PI
+ - (Math.PI * y / Math.pow(2.0, zoom - 1))))
+ * 180 / Math.PI;
+ }
+
+ private double tileXToLon(int x, int zoom) {
+ return x * 45.0 / Math.pow(2.0, zoom - 3) - 180.0;
+ }
+}
Index: applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/tms/TMSTileSource.java
===================================================================
--- applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/tms/TMSTileSource.java (revision 24501)
+++ applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/tms/TMSTileSource.java (revision 24501)
@@ -0,0 +1,13 @@
+package org.openstreetmap.josm.plugins.imagery.tms;
+
+import org.openstreetmap.gui.jmapviewer.OsmTileSource;
+
+public class TMSTileSource extends OsmTileSource.AbstractOsmTileSource {
+ public TMSTileSource(String name, String url) {
+ super(name, url);
+ }
+ @Override
+ public TileUpdate getTileUpdate() {
+ return TileUpdate.IfNoneMatch;
+ }
+}
Index: applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/wms/AddWMSLayerPanel.java
===================================================================
--- applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/wms/AddWMSLayerPanel.java (revision 24501)
+++ applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/wms/AddWMSLayerPanel.java (revision 24501)
@@ -0,0 +1,530 @@
+package org.openstreetmap.josm.plugins.imagery.wms;
+
+import static org.openstreetmap.josm.tools.I18n.tr;
+
+import java.awt.Component;
+import java.awt.Cursor;
+import java.awt.GridBagConstraints;
+import java.awt.GridBagLayout;
+import java.awt.HeadlessException;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.StringReader;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JTextArea;
+import javax.swing.JTextField;
+import javax.swing.JTree;
+import javax.swing.event.TreeSelectionEvent;
+import javax.swing.event.TreeSelectionListener;
+import javax.swing.tree.DefaultMutableTreeNode;
+import javax.swing.tree.DefaultTreeCellRenderer;
+import javax.swing.tree.DefaultTreeModel;
+import javax.swing.tree.MutableTreeNode;
+import javax.swing.tree.TreePath;
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+
+import org.openstreetmap.josm.data.Bounds;
+import org.openstreetmap.josm.data.projection.Projection;
+import org.openstreetmap.josm.data.projection.ProjectionSubPrefs;
+import org.openstreetmap.josm.gui.bbox.SlippyMapBBoxChooser;
+import org.openstreetmap.josm.tools.GBC;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+import org.xml.sax.EntityResolver;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+
+
+public class AddWMSLayerPanel extends JPanel {
+ private List selectedLayers;
+ private URL serviceUrl;
+ private LayerDetails selectedLayer;
+
+ private JTextField menuName;
+ private JTextArea resultingLayerField;
+ private MutableTreeNode treeRootNode;
+ private DefaultTreeModel treeData;
+ private JTree layerTree;
+ private JButton showBoundsButton;
+
+ private boolean previouslyShownUnsupportedCrsError = false;
+
+ public AddWMSLayerPanel() {
+ JPanel wmsFetchPanel = new JPanel(new GridBagLayout());
+ menuName = new JTextField(40);
+ menuName.setText(tr("Unnamed WMS Layer"));
+ final JTextArea serviceUrl = new JTextArea(3, 40);
+ serviceUrl.setLineWrap(true);
+ serviceUrl.setText("http://sample.com/wms?");
+ wmsFetchPanel.add(new JLabel(tr("Menu Name")), GBC.std().insets(0,0,5,0));
+ wmsFetchPanel.add(menuName, GBC.eop().insets(5,0,0,0).fill(GridBagConstraints.HORIZONTAL));
+ wmsFetchPanel.add(new JLabel(tr("Service URL")), GBC.std().insets(0,0,5,0));
+ JScrollPane scrollPane = new JScrollPane(serviceUrl,
+ JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,
+ JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
+ wmsFetchPanel.add(scrollPane, GBC.eop().insets(5,0,0,0));
+ JButton getLayersButton = new JButton(tr("Get Layers"));
+ getLayersButton.addActionListener(new ActionListener() {
+ @Override
+ public void actionPerformed(ActionEvent e) {
+ Cursor beforeCursor = getCursor();
+ try {
+ setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
+ attemptGetCapabilities(serviceUrl.getText());
+ } finally {
+ setCursor(beforeCursor);
+ }
+ }
+ });
+ wmsFetchPanel.add(getLayersButton, GBC.eop().anchor(GridBagConstraints.EAST));
+
+ treeRootNode = new DefaultMutableTreeNode();
+ treeData = new DefaultTreeModel(treeRootNode);
+ layerTree = new JTree(treeData);
+ layerTree.setCellRenderer(new LayerTreeCellRenderer());
+ layerTree.addTreeSelectionListener(new TreeSelectionListener() {
+
+ @Override
+ public void valueChanged(TreeSelectionEvent e) {
+ TreePath[] selectionRows = layerTree.getSelectionPaths();
+ if(selectionRows == null) {
+ showBoundsButton.setEnabled(false);
+ selectedLayer = null;
+ return;
+ }
+
+ selectedLayers = new LinkedList();
+ for (TreePath i : selectionRows) {
+ Object userObject = ((DefaultMutableTreeNode) i.getLastPathComponent()).getUserObject();
+ if(userObject instanceof LayerDetails) {
+ LayerDetails detail = (LayerDetails) userObject;
+ if(!detail.isSupported()) {
+ layerTree.removeSelectionPath(i);
+ if(!previouslyShownUnsupportedCrsError) {
+ JOptionPane.showMessageDialog(null, tr("That layer does not support any of JOSM's projections,\n" +
+ "so you can not use it. This message will not show again."),
+ tr("WMS Error"), JOptionPane.ERROR_MESSAGE);
+ previouslyShownUnsupportedCrsError = true;
+ }
+ } else if(detail.ident != null) {
+ selectedLayers.add(detail);
+ }
+ }
+ }
+
+ if (!selectedLayers.isEmpty()) {
+ resultingLayerField.setText(buildGetMapUrl());
+
+ if(selectedLayers.size() == 1) {
+ showBoundsButton.setEnabled(true);
+ selectedLayer = selectedLayers.get(0);
+ }
+ } else {
+ showBoundsButton.setEnabled(false);
+ selectedLayer = null;
+ }
+ }
+ });
+ wmsFetchPanel.add(new JScrollPane(layerTree), GBC.eop().insets(5,0,0,0).fill(GridBagConstraints.HORIZONTAL));
+
+ JPanel layerManipulationButtons = new JPanel();
+ showBoundsButton = new JButton(tr("Show Bounds"));
+ showBoundsButton.setEnabled(false);
+ showBoundsButton.addActionListener(new ActionListener() {
+ @Override
+ public void actionPerformed(ActionEvent e) {
+ if(selectedLayer.bounds != null) {
+ SlippyMapBBoxChooser mapPanel = new SlippyMapBBoxChooser();
+ mapPanel.setBoundingBox(selectedLayer.bounds);
+ JOptionPane.showMessageDialog(null, mapPanel, tr("Show Bounds"), JOptionPane.PLAIN_MESSAGE);
+ } else {
+ JOptionPane.showMessageDialog(null, tr("No bounding box was found for this layer."),
+ tr("WMS Error"), JOptionPane.ERROR_MESSAGE);
+ }
+ }
+ });
+ layerManipulationButtons.add(showBoundsButton);
+
+ wmsFetchPanel.add(layerManipulationButtons, GBC.eol().insets(0,0,5,0));
+ wmsFetchPanel.add(new JLabel(tr("WMS URL")), GBC.std().insets(0,0,5,0));
+ resultingLayerField = new JTextArea(3, 40);
+ resultingLayerField.setLineWrap(true);
+ wmsFetchPanel.add(new JScrollPane(resultingLayerField, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, JScrollPane.HORIZONTAL_SCROLLBAR_NEVER), GBC.eop().insets(5,0,0,0).fill(GridBagConstraints.HORIZONTAL));
+
+ add(wmsFetchPanel);
+ }
+
+ private String buildRootUrl() {
+ StringBuilder a = new StringBuilder(serviceUrl.getProtocol());
+ a.append("://");
+ a.append(serviceUrl.getHost());
+ if(serviceUrl.getPort() != -1) {
+ a.append(":");
+ a.append(serviceUrl.getPort());
+ }
+ a.append(serviceUrl.getPath());
+ a.append("?");
+ if(serviceUrl.getQuery() != null) {
+ a.append(serviceUrl.getQuery());
+ if (!serviceUrl.getQuery().isEmpty() && !serviceUrl.getQuery().endsWith("&")) {
+ a.append("&");
+ }
+ }
+ return a.toString();
+ }
+
+ private String buildGetMapUrl() {
+ StringBuilder a = new StringBuilder();
+ a.append(buildRootUrl());
+ a.append("FORMAT=image/jpeg&VERSION=1.1.1&SERVICE=WMS&REQUEST=GetMap&Layers=");
+ a.append(commaSepLayerList());
+ a.append("&");
+
+ return a.toString();
+ }
+
+ private String commaSepLayerList() {
+ StringBuilder b = new StringBuilder();
+
+ Iterator iterator = selectedLayers.iterator();
+ while (iterator.hasNext()) {
+ LayerDetails layerDetails = iterator.next();
+ b.append(layerDetails.ident);
+ if(iterator.hasNext()) {
+ b.append(",");
+ }
+ }
+
+ return b.toString();
+ }
+
+ private void showError(String incomingData, Exception e) {
+ JOptionPane.showMessageDialog(this, tr("Could not parse WMS layer list."),
+ tr("WMS Error"), JOptionPane.ERROR_MESSAGE);
+ System.err.println("Could not parse WMS layer list. Incoming data:");
+ System.err.println(incomingData);
+ e.printStackTrace();
+ }
+
+ private void attemptGetCapabilities(String serviceUrlStr) {
+ URL getCapabilitiesUrl = null;
+ try {
+ if (!serviceUrlStr.trim().contains("capabilities")) {
+ // If the url doesn't already have GetCapabilities, add it in
+ getCapabilitiesUrl = new URL(serviceUrlStr + "VERSION=1.1.1&SERVICE=WMS&REQUEST=GetCapabilities");
+ } else {
+ // Otherwise assume it's a good URL and let the subsequent error
+ // handling systems deal with problems
+ getCapabilitiesUrl = new URL(serviceUrlStr);
+ }
+ serviceUrl = new URL(serviceUrlStr);
+ } catch (HeadlessException e) {
+ return;
+ } catch (MalformedURLException e) {
+ JOptionPane.showMessageDialog(this, tr("Invalid service URL."),
+ tr("WMS Error"), JOptionPane.ERROR_MESSAGE);
+ return;
+ }
+
+ String incomingData;
+ try {
+ URLConnection openConnection = getCapabilitiesUrl.openConnection();
+ InputStream inputStream = openConnection.getInputStream();
+ BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
+ String line;
+ StringBuilder ba = new StringBuilder();
+ while((line = br.readLine()) != null) {
+ ba.append(line);
+ ba.append("\n");
+ }
+ incomingData = ba.toString();
+ } catch (IOException e) {
+ JOptionPane.showMessageDialog(this, tr("Could not retrieve WMS layer list."),
+ tr("WMS Error"), JOptionPane.ERROR_MESSAGE);
+ return;
+ }
+
+ Document document;
+ try {
+ DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
+ builderFactory.setValidating(false);
+ builderFactory.setNamespaceAware(true);
+ DocumentBuilder builder = builderFactory.newDocumentBuilder();
+ builder.setEntityResolver(new EntityResolver() {
+ @Override
+ public InputSource resolveEntity(String publicId, String systemId) throws SAXException, IOException {
+ System.out.println("Ignoring DTD " + publicId + ", " + systemId);
+ return new InputSource(new StringReader(""));
+ }
+ });
+ document = builder.parse(new InputSource(new StringReader(incomingData)));
+ } catch (ParserConfigurationException e) {
+ showError(incomingData, e);
+ return;
+ } catch (SAXException e) {
+ showError(incomingData, e);
+ return;
+ } catch (IOException e) {
+ showError(incomingData, e);
+ return;
+ }
+
+ // Some WMS service URLs specify a different base URL for their GetMap service
+ Element child = getChild(document.getDocumentElement(), "Capability");
+ child = getChild(child, "Request");
+ child = getChild(child, "GetMap");
+ child = getChild(child, "DCPType");
+ child = getChild(child, "HTTP");
+ child = getChild(child, "Get");
+ child = getChild(child, "OnlineResource");
+ if (child != null) {
+ String baseURL = child.getAttribute("xlink:href");
+ if(baseURL != null) {
+ try {
+ System.out.println("GetCapabilities specifies a different service URL: " + baseURL);
+ serviceUrl = new URL(baseURL);
+ } catch (MalformedURLException e1) {
+ }
+ }
+ }
+
+ try {
+ treeRootNode.setUserObject(getCapabilitiesUrl.getHost());
+ Element capabilityElem = getChild(document.getDocumentElement(), "Capability");
+ List children = getChildren(capabilityElem, "Layer");
+ List layers = parseLayers(children, new HashSet());
+ updateTreeList(layers);
+ } catch(Exception e) {
+ showError(incomingData, e);
+ return;
+ }
+ }
+
+ private void updateTreeList(List layers) {
+ addLayersToTreeData(treeRootNode, layers);
+ layerTree.expandRow(0);
+ }
+
+ private void addLayersToTreeData(MutableTreeNode parent, List layers) {
+ for (LayerDetails layerDetails : layers) {
+ DefaultMutableTreeNode treeNode = new DefaultMutableTreeNode(layerDetails);
+ addLayersToTreeData(treeNode, layerDetails.children);
+ treeData.insertNodeInto(treeNode, parent, 0);
+ }
+ }
+
+ private List parseLayers(List children, Set parentCrs) {
+ List details = new LinkedList();
+ for (Element element : children) {
+ details.add(parseLayer(element, parentCrs));
+ }
+ return details;
+ }
+
+ private LayerDetails parseLayer(Element element, Set parentCrs) {
+ String name = getChildContent(element, "Title", null, null);
+ String ident = getChildContent(element, "Name", null, null);
+
+ // The set of supported CRS/SRS for this layer
+ Set crsList = new HashSet();
+ // ...including this layer's already-parsed parent projections
+ crsList.addAll(parentCrs);
+
+ // Parse the CRS/SRS pulled out of this layer's XML element
+ // I think CRS and SRS are the same at this point
+ List crsChildren = getChildren(element, "CRS");
+ crsChildren.addAll(getChildren(element, "SRS"));
+ for (Element child : crsChildren) {
+ String crs = (String) getContent(child);
+ if(crs != null) {
+ String upperCase = crs.trim().toUpperCase();
+ crsList.add(upperCase);
+ }
+ }
+
+ // Check to see if any of the specified projections are supported by JOSM
+ boolean josmSupportsThisLayer = false;
+ for (String crs : crsList) {
+ josmSupportsThisLayer |= isProjSupported(crs);
+ }
+
+ Bounds bounds = null;
+ Element bboxElem = getChild(element, "EX_GeographicBoundingBox");
+ if(bboxElem != null) {
+ // Attempt to use EX_GeographicBoundingBox for bounding box
+ double left = Double.parseDouble(getChildContent(bboxElem, "westBoundLongitude", null, null));
+ double top = Double.parseDouble(getChildContent(bboxElem, "northBoundLatitude", null, null));
+ double right = Double.parseDouble(getChildContent(bboxElem, "eastBoundLongitude", null, null));
+ double bot = Double.parseDouble(getChildContent(bboxElem, "southBoundLatitude", null, null));
+ bounds = new Bounds(bot, left, top, right);
+ } else {
+ // If that's not available, try LatLonBoundingBox
+ bboxElem = getChild(element, "LatLonBoundingBox");
+ if(bboxElem != null) {
+ double left = Double.parseDouble(bboxElem.getAttribute("minx"));
+ double top = Double.parseDouble(bboxElem.getAttribute("maxy"));
+ double right = Double.parseDouble(bboxElem.getAttribute("maxx"));
+ double bot = Double.parseDouble(bboxElem.getAttribute("miny"));
+ bounds = new Bounds(bot, left, top, right);
+ }
+ }
+
+ List layerChildren = getChildren(element, "Layer");
+ List childLayers = parseLayers(layerChildren, crsList);
+
+ return new LayerDetails(name, ident, crsList, josmSupportsThisLayer, bounds, childLayers);
+ }
+
+ private boolean isProjSupported(String crs) {
+ for (Projection proj : Projection.allProjections) {
+ if (proj instanceof ProjectionSubPrefs) {
+ if (((ProjectionSubPrefs) proj).getPreferencesFromCode(crs) == null) {
+ return true;
+ }
+ } else {
+ if (proj.toCode().equals(crs)) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ public String getUrlName() {
+ return menuName.getText();
+ }
+
+ public String getUrl() {
+ return resultingLayerField.getText();
+ }
+
+ public static void main(String[] args) {
+ JFrame f = new JFrame("Test");
+ f.setContentPane(new AddWMSLayerPanel());
+ f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+ f.pack();
+ f.setVisible(true);
+ }
+
+ private static String getChildContent(Element parent, String name, String missing, String empty) {
+ Element child = getChild(parent, name);
+ if (child == null) {
+ return missing;
+ } else {
+ String content = (String) getContent(child);
+ return (content != null) ? content : empty;
+ }
+ }
+
+ private static Object getContent(Element element) {
+ NodeList nl = element.getChildNodes();
+ StringBuffer content = new StringBuffer();
+ for (int i = 0; i < nl.getLength(); i++) {
+ Node node = nl.item(i);
+ switch (node.getNodeType()) {
+ case Node.ELEMENT_NODE:
+ return node;
+ case Node.CDATA_SECTION_NODE:
+ case Node.TEXT_NODE:
+ content.append(node.getNodeValue());
+ break;
+ }
+ }
+ return content.toString().trim();
+ }
+
+ private static List getChildren(Element parent, String name) {
+ List retVal = new LinkedList();
+ for (Node child = parent.getFirstChild(); child != null; child = child.getNextSibling()) {
+ if (child instanceof Element && name.equals(child.getNodeName())) {
+ retVal.add((Element) child);
+ }
+ }
+ return retVal;
+ }
+
+ private static Element getChild(Element parent, String name) {
+ if (parent == null) {
+ return null;
+ }
+ for (Node child = parent.getFirstChild(); child != null; child = child.getNextSibling()) {
+ if (child instanceof Element && name.equals(child.getNodeName())) {
+ return (Element) child;
+ }
+ }
+ return null;
+ }
+
+ class LayerDetails {
+
+ private String name;
+ private String ident;
+ private List children;
+ private Bounds bounds;
+ private boolean supported;
+
+ public LayerDetails(String name, String ident, Set crsList,
+ boolean supportedLayer, Bounds bounds,
+ List childLayers) {
+ this.name = name;
+ this.ident = ident;
+ this.supported = supportedLayer;
+ this.children = childLayers;
+ this.bounds = bounds;
+ }
+
+ public boolean isSupported() {
+ return this.supported;
+ }
+
+ @Override
+ public String toString() {
+ if(this.name == null || this.name.isEmpty()) {
+ return this.ident;
+ } else {
+ return this.name;
+ }
+ }
+
+ }
+
+ class LayerTreeCellRenderer extends DefaultTreeCellRenderer {
+ @Override
+ public Component getTreeCellRendererComponent(JTree tree, Object value,
+ boolean sel, boolean expanded, boolean leaf, int row,
+ boolean hasFocus) {
+ super.getTreeCellRendererComponent(tree, value, sel, expanded, leaf,
+ row, hasFocus);
+ DefaultMutableTreeNode treeNode = (DefaultMutableTreeNode) value;
+ Object userObject = treeNode.getUserObject();
+ if (userObject instanceof LayerDetails) {
+ LayerDetails layer = (LayerDetails) userObject;
+ setEnabled(layer.isSupported());
+ }
+ return this;
+ }
+ }
+
+}
Index: applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/wms/GeorefImage.java
===================================================================
--- applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/wms/GeorefImage.java (revision 24501)
+++ applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/wms/GeorefImage.java (revision 24501)
@@ -0,0 +1,223 @@
+package org.openstreetmap.josm.plugins.imagery.wms;
+
+import static org.openstreetmap.josm.tools.I18n.tr;
+
+import java.awt.Color;
+import java.awt.Font;
+import java.awt.Graphics;
+import java.awt.Image;
+import java.awt.Transparency;
+import java.awt.image.BufferedImage;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+import java.lang.ref.SoftReference;
+
+import javax.imageio.ImageIO;
+
+import org.openstreetmap.josm.data.coor.EastNorth;
+import org.openstreetmap.josm.gui.NavigatableComponent;
+
+public class GeorefImage implements Serializable {
+ private static final long serialVersionUID = 1L;
+
+ public enum State { IMAGE, NOT_IN_CACHE, FAILED};
+
+ private WMSLayer layer;
+ private State state;
+
+ private BufferedImage image;
+ private SoftReference reImg;
+ private int xIndex;
+ private int yIndex;
+
+
+ public EastNorth getMin() {
+ return layer.getEastNorth(xIndex, yIndex);
+ }
+
+ public EastNorth getMax() {
+ return layer.getEastNorth(xIndex+1, yIndex+1);
+ }
+
+
+ public GeorefImage(WMSLayer layer) {
+ this.layer = layer;
+ }
+
+ public void changePosition(int xIndex, int yIndex) {
+ if (!equalPosition(xIndex, yIndex)) {
+ this.xIndex = xIndex;
+ this.yIndex = yIndex;
+ this.image = null;
+ flushedResizedCachedInstance();
+ }
+ }
+
+ public boolean equalPosition(int xIndex, int yIndex) {
+ return this.xIndex == xIndex && this.yIndex == yIndex;
+ }
+
+ public void changeImage(State state, BufferedImage image) {
+ flushedResizedCachedInstance();
+ this.image = image;
+ this.state = state;
+
+ switch (state) {
+ case FAILED:
+ {
+ BufferedImage img = createImage();
+ Graphics g = img.getGraphics();
+ g.setColor(Color.RED);
+ g.fillRect(0, 0, img.getWidth(), img.getHeight());
+ g.setFont(g.getFont().deriveFont(Font.PLAIN).deriveFont(36.0f));
+ g.setColor(Color.BLACK);
+ g.drawString(tr("Exception occurred"), 10, img.getHeight()/2);
+ this.image = img;
+ break;
+ }
+ case NOT_IN_CACHE:
+ {
+ BufferedImage img = createImage();
+ Graphics g = img.getGraphics();
+ g.setColor(Color.GRAY);
+ g.fillRect(0, 0, img.getWidth(), img.getHeight());
+ Font font = g.getFont();
+ Font tempFont = font.deriveFont(Font.PLAIN).deriveFont(36.0f);
+ g.setFont(tempFont);
+ g.setColor(Color.BLACK);
+ g.drawString(tr("Not in cache"), 10, img.getHeight()/2);
+ g.setFont(font);
+ this.image = img;
+ break;
+ }
+ default:
+ break;
+ }
+ }
+
+ private BufferedImage createImage() {
+ return new BufferedImage(layer.getBaseImageWidth(), layer.getBaseImageHeight(), BufferedImage.TYPE_INT_RGB);
+ }
+
+ public boolean paint(Graphics g, NavigatableComponent nc, int xIndex, int yIndex, int leftEdge, int bottomEdge) {
+ if (image == null)
+ return false;
+
+ if(!(this.xIndex == xIndex && this.yIndex == yIndex)){
+ return false;
+ }
+
+ int left = layer.getImageX(xIndex);
+ int bottom = layer.getImageY(yIndex);
+ int width = layer.getImageWidth(xIndex);
+ int height = layer.getImageHeight(yIndex);
+
+ int x = left - leftEdge;
+ int y = nc.getHeight() - (bottom - bottomEdge) - height;
+
+ // This happens if you zoom outside the world
+ if(width == 0 || height == 0)
+ return false;
+
+ BufferedImage img = reImg == null?null:reImg.get();
+ if(img != null && img.getWidth() == width && img.getHeight() == height) {
+ g.drawImage(img, x, y, null);
+ return true;
+ }
+
+ boolean alphaChannel = WMSLayer.PROP_ALPHA_CHANNEL.get() && getImage().getTransparency() != Transparency.OPAQUE;
+
+ try {
+ if(img != null) img.flush();
+ long freeMem = Runtime.getRuntime().maxMemory() - Runtime.getRuntime().totalMemory();
+ //System.out.println("Free Memory: "+ (freeMem/1024/1024) +" MB");
+ // Notice that this value can get negative due to integer overflows
+ //System.out.println("Img Size: "+ (width*height*3/1024/1024) +" MB");
+
+ int multipl = alphaChannel ? 4 : 3;
+ // This happens when requesting images while zoomed out and then zooming in
+ // Storing images this large in memory will certainly hang up JOSM. Luckily
+ // traditional rendering is as fast at these zoom levels, so it's no loss.
+ // Also prevent caching if we're out of memory soon
+ if(width > 2000 || height > 2000 || width*height*multipl > freeMem) {
+ fallbackDraw(g, getImage(), x, y, width, height);
+ } else {
+ // We haven't got a saved resized copy, so resize and cache it
+ img = new BufferedImage(width, height, alphaChannel?BufferedImage.TYPE_INT_ARGB:BufferedImage.TYPE_3BYTE_BGR);
+ img.getGraphics().drawImage(getImage(),
+ 0, 0, width, height, // dest
+ 0, 0, getImage().getWidth(null), getImage().getHeight(null), // src
+ null);
+ img.getGraphics().dispose();
+ g.drawImage(img, x, y, null);
+ reImg = new SoftReference(img);
+ }
+ } catch(Exception e) {
+ fallbackDraw(g, getImage(), x, y, width, height);
+ }
+ return true;
+ }
+
+ private void fallbackDraw(Graphics g, Image img, int x, int y, int width, int height) {
+ flushedResizedCachedInstance();
+ g.drawImage(
+ img, x, y, x + width, y + height,
+ 0, 0, img.getWidth(null), img.getHeight(null),
+ null);
+ }
+
+ private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
+ state = (State) in.readObject();
+ boolean hasImage = in.readBoolean();
+ if (hasImage)
+ image = (ImageIO.read(ImageIO.createImageInputStream(in)));
+ else {
+ in.readObject(); // read null from input stream
+ image = null;
+ }
+ }
+
+ private void writeObject(ObjectOutputStream out) throws IOException {
+ out.writeObject(state);
+ if(getImage() == null) {
+ out.writeBoolean(false);
+ out.writeObject(null);
+ } else {
+ out.writeBoolean(true);
+ ImageIO.write(getImage(), "png", ImageIO.createImageOutputStream(out));
+ }
+ }
+
+ public void flushedResizedCachedInstance() {
+ if (reImg != null) {
+ BufferedImage img = reImg.get();
+ if (img != null) {
+ img.flush();
+ }
+ }
+ reImg = null;
+ }
+
+
+ public BufferedImage getImage() {
+ return image;
+ }
+
+ public State getState() {
+ return state;
+ }
+
+ public int getXIndex() {
+ return xIndex;
+ }
+
+ public int getYIndex() {
+ return yIndex;
+ }
+
+ public void setLayer(WMSLayer layer) {
+ this.layer = layer;
+ }
+}
Index: applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/wms/Grabber.java
===================================================================
--- applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/wms/Grabber.java (revision 24501)
+++ applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/wms/Grabber.java (revision 24501)
@@ -0,0 +1,115 @@
+package org.openstreetmap.josm.plugins.imagery.wms;
+
+import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.data.ProjectionBounds;
+import org.openstreetmap.josm.data.coor.EastNorth;
+import org.openstreetmap.josm.data.projection.Projection;
+import org.openstreetmap.josm.gui.MapView;
+import org.openstreetmap.josm.io.CacheFiles;
+import org.openstreetmap.josm.plugins.imagery.ImageryPlugin;
+import org.openstreetmap.josm.plugins.imagery.wms.GeorefImage.State;
+
+abstract public class Grabber implements Runnable {
+ protected final MapView mv;
+ protected final WMSLayer layer;
+ protected final CacheFiles cache;
+
+ protected ProjectionBounds b;
+ protected Projection proj;
+ protected double pixelPerDegree;
+ protected WMSRequest request;
+ protected volatile boolean canceled;
+
+ Grabber(MapView mv, WMSLayer layer, CacheFiles cache) {
+ this.mv = mv;
+ this.layer = layer;
+ this.cache = cache;
+ }
+
+ private void updateState(WMSRequest request) {
+ b = new ProjectionBounds(
+ layer.getEastNorth(request.getXIndex(), request.getYIndex()),
+ layer.getEastNorth(request.getXIndex() + 1, request.getYIndex() + 1));
+ if (b.min != null && b.max != null && ImageryPlugin.wmsAdapter.PROP_OVERLAP.get()) {
+ double eastSize = b.max.east() - b.min.east();
+ double northSize = b.max.north() - b.min.north();
+
+ double eastCoef = ImageryPlugin.wmsAdapter.PROP_OVERLAP_EAST.get() / 100.0;
+ double northCoef = ImageryPlugin.wmsAdapter.PROP_OVERLAP_NORTH.get() / 100.0;
+
+ this.b = new ProjectionBounds( new EastNorth(b.min.east(),
+ b.min.north()),
+ new EastNorth(b.max.east() + eastCoef * eastSize,
+ b.max.north() + northCoef * northSize));
+ }
+
+ this.proj = Main.proj;
+ this.pixelPerDegree = request.getPixelPerDegree();
+ this.request = request;
+ }
+
+ abstract void fetch(WMSRequest request) throws Exception; // the image fetch code
+
+ int width(){
+ return layer.getBaseImageWidth();
+ }
+ int height(){
+ return layer.getBaseImageHeight();
+ }
+
+ @Override
+ public void run() {
+ while (true) {
+ if (canceled) {
+ return;
+ }
+ WMSRequest request = layer.getRequest();
+ if (request == null) {
+ return;
+ }
+ updateState(request);
+ if(!loadFromCache(request)){
+ attempt(request);
+ }
+ if (request.getState() != null) {
+ layer.finishRequest(request);
+ mv.repaint();
+ }
+ }
+ }
+
+ protected void attempt(WMSRequest request){ // try to fetch the image
+ int maxTries = 5; // n tries for every image
+ for (int i = 1; i <= maxTries; i++) {
+ if (canceled) {
+ return;
+ }
+ try {
+ if (!layer.requestIsValid(request)) {
+ return;
+ }
+ fetch(request);
+ break; // break out of the retry loop
+ } catch (Exception e) {
+ try { // sleep some time and then ask the server again
+ Thread.sleep(random(1000, 2000));
+ } catch (InterruptedException e1) {}
+
+ if(i == maxTries) {
+ e.printStackTrace();
+ request.finish(State.FAILED, null);
+ }
+ }
+ }
+ }
+
+ public static int random(int min, int max) {
+ return (int)(Math.random() * ((max+1)-min) ) + min;
+ }
+
+ abstract public boolean loadFromCache(WMSRequest request);
+
+ public void cancel() {
+ canceled = true;
+ }
+}
Index: applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/wms/HTMLGrabber.java
===================================================================
--- applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/wms/HTMLGrabber.java (revision 24501)
+++ applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/wms/HTMLGrabber.java (revision 24501)
@@ -0,0 +1,46 @@
+package org.openstreetmap.josm.plugins.imagery.wms;
+
+import java.awt.image.BufferedImage;
+import java.io.IOException;
+import java.net.URL;
+import java.text.MessageFormat;
+import java.util.ArrayList;
+import java.util.StringTokenizer;
+
+import javax.imageio.ImageIO;
+
+import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.gui.MapView;
+import org.openstreetmap.josm.io.CacheFiles;
+
+public class HTMLGrabber extends WMSGrabber {
+ HTMLGrabber(MapView mv, WMSLayer layer, CacheFiles cache) {
+ super(mv, layer, cache);
+ }
+
+ @Override
+ protected BufferedImage grab(URL url) throws IOException {
+ String urlstring = url.toExternalForm();
+
+ System.out.println("Grabbing HTML " + url);
+
+ ArrayList cmdParams = new ArrayList();
+ StringTokenizer st = new StringTokenizer(MessageFormat.format(
+ Main.pref.get("wmsplugin.browser", "webkit-image {0}"), urlstring));
+ while( st.hasMoreTokens() )
+ cmdParams.add(st.nextToken());
+
+ ProcessBuilder builder = new ProcessBuilder( cmdParams);
+
+ Process browser;
+ try {
+ browser = builder.start();
+ } catch(IOException ioe) {
+ throw new IOException( "Could not start browser. Please check that the executable path is correct.\n" + ioe.getMessage() );
+ }
+
+ BufferedImage img = ImageIO.read(browser.getInputStream());
+ cache.saveImg(urlstring, img);
+ return img;
+ }
+}
Index: applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/wms/Map_Rectifier_WMSmenuAction.java
===================================================================
--- applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/wms/Map_Rectifier_WMSmenuAction.java (revision 24501)
+++ applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/wms/Map_Rectifier_WMSmenuAction.java (revision 24501)
@@ -0,0 +1,238 @@
+package org.openstreetmap.josm.plugins.imagery.wms;
+
+import static org.openstreetmap.josm.tools.I18n.tr;
+
+import java.awt.GridBagConstraints;
+import java.awt.GridBagLayout;
+import java.awt.Toolkit;
+import java.awt.datatransfer.DataFlavor;
+import java.awt.datatransfer.Transferable;
+import java.awt.event.ActionEvent;
+import java.awt.event.KeyEvent;
+import java.util.ArrayList;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import javax.swing.ButtonGroup;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JRadioButton;
+import javax.swing.JTextField;
+
+import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.actions.JosmAction;
+import org.openstreetmap.josm.gui.ExtendedDialog;
+import org.openstreetmap.josm.plugins.imagery.ImageryInfo;
+import org.openstreetmap.josm.tools.GBC;
+import org.openstreetmap.josm.tools.Shortcut;
+import org.openstreetmap.josm.tools.UrlLabel;
+
+public class Map_Rectifier_WMSmenuAction extends JosmAction {
+ /**
+ * Class that bundles all required information of a rectifier service
+ */
+ public static class RectifierService {
+ private final String name;
+ private final String url;
+ private final String wmsUrl;
+ private final Pattern urlRegEx;
+ private final Pattern idValidator;
+ public JRadioButton btn;
+ /**
+ * @param name: Name of the rectifing service
+ * @param url: URL to the service where users can register, upload, etc.
+ * @param wmsUrl: URL to the WMS server where JOSM will grab the images. Insert __s__ where the ID should be placed
+ * @param urlRegEx: a regular expression that determines if a given URL is one of the service and returns the WMS id if so
+ * @param idValidator: regular expression that checks if a given ID is syntactically valid
+ */
+ public RectifierService(String name, String url, String wmsUrl, String urlRegEx, String idValidator) {
+ this.name = name;
+ this.url = url;
+ this.wmsUrl = wmsUrl;
+ this.urlRegEx = Pattern.compile(urlRegEx);
+ this.idValidator = Pattern.compile(idValidator);
+ }
+
+ public boolean isSelected() {
+ return btn.isSelected();
+ }
+ }
+
+ /**
+ * List of available rectifier services. May be extended from the outside
+ */
+ public ArrayList services = new ArrayList();
+
+ public Map_Rectifier_WMSmenuAction() {
+ super(tr("Rectified Image..."),
+ "OLmarker",
+ tr("Download Rectified Images From Various Services"),
+ Shortcut.registerShortcut("wms:rectimg",
+ tr("WMS: {0}", tr("Rectified Image...")),
+ KeyEvent.VK_R,
+ Shortcut.GROUP_NONE),
+ true
+ );
+
+ // Add default services
+ services.add(
+ new RectifierService("Metacarta Map Rectifier",
+ "http://labs.metacarta.com/rectifier/",
+ "http://labs.metacarta.com/rectifier/wms.cgi?id=__s__&srs=EPSG:4326"
+ + "&Service=WMS&Version=1.1.0&Request=GetMap&format=image/png&",
+ // This matches more than the "classic" WMS link, so users can pretty much
+ // copy any link as long as it includes the ID
+ "labs\\.metacarta\\.com/(?:.*?)(?:/|=)([0-9]+)(?:\\?|/|\\.|$)",
+ "^[0-9]+$")
+ );
+ services.add(
+ // TODO: Change all links to mapwarper.net once the project has moved.
+ // The RegEx already matches the new URL and old URLs will be forwarded
+ // to make the transition as smooth as possible for the users
+ new RectifierService("Geothings Map Warper",
+ "http://warper.geothings.net/",
+ "http://warper.geothings.net/maps/wms/__s__?request=GetMap&version=1.1.1"
+ + "&styles=&format=image/png&srs=epsg:4326&exceptions=application/vnd.ogc.se_inimage&",
+ // This matches more than the "classic" WMS link, so users can pretty much
+ // copy any link as long as it includes the ID
+ "(?:mapwarper\\.net|warper\\.geothings\\.net)/(?:.*?)/([0-9]+)(?:\\?|/|\\.|$)",
+ "^[0-9]+$")
+ );
+
+ // This service serves the purpose of "just this once" without forcing the user
+ // to commit the link to the preferences
+
+ // Clipboard content gets trimmed, so matching whitespace only ensures that this
+ // service will never be selected automatically.
+ services.add(new RectifierService(tr("Custom WMS Link"), "", "", "^\\s+$", ""));
+ }
+
+ @Override
+ public void actionPerformed(ActionEvent e) {
+ JPanel panel = new JPanel(new GridBagLayout());
+ panel.add(new JLabel(tr("Supported Rectifier Services:")), GBC.eol());
+
+ JTextField tfWmsUrl = new JTextField(30);
+
+ String clip = getClipboardContents();
+ ButtonGroup group = new ButtonGroup();
+
+ JRadioButton firstBtn = null;
+ for(RectifierService s : services) {
+ JRadioButton serviceBtn = new JRadioButton(s.name);
+ if(firstBtn == null)
+ firstBtn = serviceBtn;
+ // Checks clipboard contents against current service if no match has been found yet.
+ // If the contents match, they will be inserted into the text field and the corresponding
+ // service will be pre-selected.
+ if(!clip.equals("") && tfWmsUrl.getText().equals("")
+ && (s.urlRegEx.matcher(clip).find() || s.idValidator.matcher(clip).matches())) {
+ serviceBtn.setSelected(true);
+ tfWmsUrl.setText(clip);
+ }
+ s.btn = serviceBtn;
+ group.add(serviceBtn);
+ if(!s.url.equals("")) {
+ panel.add(serviceBtn, GBC.std());
+ panel.add(new UrlLabel(s.url, tr("Visit Homepage")), GBC.eol().anchor(GridBagConstraints.EAST));
+ } else
+ panel.add(serviceBtn, GBC.eol().anchor(GridBagConstraints.WEST));
+ }
+
+ // Fallback in case no match was found
+ if(tfWmsUrl.getText().equals("") && firstBtn != null)
+ firstBtn.setSelected(true);
+
+ panel.add(new JLabel(tr("WMS URL or Image ID:")), GBC.eol());
+ panel.add(tfWmsUrl, GBC.eol().fill(GridBagConstraints.HORIZONTAL));
+
+ ExtendedDialog diag = new ExtendedDialog(Main.parent,
+ tr("Add Rectified Image"),
+
+ new String[] {tr("Add Rectified Image"), tr("Cancel")});
+ diag.setContent(panel);
+ diag.setButtonIcons(new String[] {"OLmarker.png", "cancel.png"});
+
+ // This repeatedly shows the dialog in case there has been an error.
+ // The loop is break;-ed if the users cancels
+ outer: while(true) {
+ diag.showDialog();
+ int answer = diag.getValue();
+ // Break loop when the user cancels
+ if(answer != 1)
+ break;
+
+ String text = tfWmsUrl.getText().trim();
+ // Loop all services until we find the selected one
+ for(RectifierService s : services) {
+ if(!s.isSelected())
+ continue;
+
+ // We've reached the custom WMS URL service
+ // Just set the URL and hope everything works out
+ if(s.wmsUrl.equals("")) {
+ addWMSLayer(s.name + " (" + text + ")", text);
+ break outer;
+ }
+
+ // First try to match if the entered string as an URL
+ Matcher m = s.urlRegEx.matcher(text);
+ if(m.find()) {
+ String id = m.group(1);
+ String newURL = s.wmsUrl.replaceAll("__s__", id);
+ String title = s.name + " (" + id + ")";
+ addWMSLayer(title, newURL);
+ break outer;
+ }
+ // If not, look if it's a valid ID for the selected service
+ if(s.idValidator.matcher(text).matches()) {
+ String newURL = s.wmsUrl.replaceAll("__s__", text);
+ String title = s.name + " (" + text + ")";
+ addWMSLayer(title, newURL);
+ break outer;
+ }
+
+ // We've found the selected service, but the entered string isn't suitable for
+ // it. So quit checking the other radio buttons
+ break;
+ }
+
+ // and display an error message. The while(true) ensures that the dialog pops up again
+ JOptionPane.showMessageDialog(Main.parent,
+ tr("Couldn't match the entered link or id to the selected service. Please try again."),
+ tr("No valid WMS URL or id"),
+ JOptionPane.ERROR_MESSAGE);
+ diag.setVisible(true);
+ }
+ }
+
+ /**
+ * Adds a WMS Layer with given title and URL
+ * @param title: Name of the layer as it will shop up in the layer manager
+ * @param url: URL to the WMS server
+ */
+ private void addWMSLayer(String title, String url) {
+ Main.main.addLayer(new WMSLayer(new ImageryInfo(title, url)));
+ }
+
+ /**
+ * Helper function that extracts a String from the Clipboard if available.
+ * Returns an empty String otherwise
+ * @return String Clipboard contents if available
+ */
+ private String getClipboardContents() {
+ String result = "";
+ Transferable contents = Toolkit.getDefaultToolkit().getSystemClipboard().getContents(null);
+
+ if(contents == null || !contents.isDataFlavorSupported(DataFlavor.stringFlavor))
+ return "";
+
+ try {
+ result = (String)contents.getTransferData(DataFlavor.stringFlavor);
+ } catch(Exception ex) {
+ return "";
+ }
+ return result.trim();
+ }
+}
Index: applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/wms/WMSAdapter.java
===================================================================
--- applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/wms/WMSAdapter.java (revision 24501)
+++ applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/wms/WMSAdapter.java (revision 24501)
@@ -0,0 +1,40 @@
+package org.openstreetmap.josm.plugins.imagery.wms;
+
+import org.openstreetmap.josm.actions.ExtensionFileFilter;
+import org.openstreetmap.josm.data.preferences.BooleanProperty;
+import org.openstreetmap.josm.data.preferences.IntegerProperty;
+import org.openstreetmap.josm.gui.MapView;
+import org.openstreetmap.josm.io.CacheFiles;
+import org.openstreetmap.josm.plugins.imagery.ImageryInfo.ImageryType;
+import org.openstreetmap.josm.plugins.imagery.wms.io.WMSLayerExporter;
+import org.openstreetmap.josm.plugins.imagery.wms.io.WMSLayerImporter;
+
+// WMSPlugin-specific functions
+public class WMSAdapter {
+ CacheFiles cache = new CacheFiles("wmsplugin");
+
+ public final IntegerProperty PROP_SIMULTANEOUS_CONNECTIONS = new IntegerProperty("wmsplugin.simultaneousConnections", 3);
+ public final BooleanProperty PROP_OVERLAP = new BooleanProperty("wmsplugin.url.overlap", false);
+ public final IntegerProperty PROP_OVERLAP_EAST = new IntegerProperty("wmsplugin.url.overlapEast", 14);
+ public final IntegerProperty PROP_OVERLAP_NORTH = new IntegerProperty("wmsplugin.url.overlapNorth", 4);
+
+ protected void initExporterAndImporter() {
+ ExtensionFileFilter.exporters.add(new WMSLayerExporter());
+ ExtensionFileFilter.importers.add(new WMSLayerImporter());
+ }
+
+ public WMSAdapter() {
+ cache.setExpire(CacheFiles.EXPIRE_MONTHLY, false);
+ cache.setMaxSize(70, false);
+ initExporterAndImporter();
+ }
+
+ public Grabber getGrabber(MapView mv, WMSLayer layer){
+ if(layer.info.getImageryType() == ImageryType.HTML)
+ return new HTMLGrabber(mv, layer, cache);
+ else if(layer.info.getImageryType() == ImageryType.WMS)
+ return new WMSGrabber(mv, layer, cache);
+ else throw new AssertionError();
+ }
+
+}
Index: applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/wms/WMSGrabber.java
===================================================================
--- applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/wms/WMSGrabber.java (revision 24501)
+++ applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/wms/WMSGrabber.java (revision 24501)
@@ -0,0 +1,203 @@
+package org.openstreetmap.josm.plugins.imagery.wms;
+
+import static org.openstreetmap.josm.tools.I18n.tr;
+
+import java.awt.image.BufferedImage;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.net.HttpURLConnection;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLConnection;
+import java.text.DecimalFormat;
+import java.text.DecimalFormatSymbols;
+import java.text.NumberFormat;
+import java.util.Locale;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import javax.imageio.ImageIO;
+import javax.swing.JOptionPane;
+
+import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.data.Version;
+import org.openstreetmap.josm.data.coor.EastNorth;
+import org.openstreetmap.josm.data.coor.LatLon;
+import org.openstreetmap.josm.data.projection.Mercator;
+import org.openstreetmap.josm.gui.MapView;
+import org.openstreetmap.josm.io.CacheFiles;
+import org.openstreetmap.josm.io.OsmTransferException;
+import org.openstreetmap.josm.io.ProgressInputStream;
+import org.openstreetmap.josm.plugins.imagery.wms.GeorefImage.State;
+
+
+public class WMSGrabber extends Grabber {
+ public static boolean isUrlWithPatterns(String url) {
+ return url != null && url.contains("{") && url.contains("}");
+ }
+
+ protected String baseURL;
+ private final boolean urlWithPatterns;
+
+ WMSGrabber(MapView mv, WMSLayer layer, CacheFiles cache) {
+ super(mv, layer, cache);
+ this.baseURL = layer.info.getURL();
+ /* URL containing placeholders? */
+ urlWithPatterns = isUrlWithPatterns(baseURL);
+ }
+
+ @Override
+ void fetch(WMSRequest request) throws Exception{
+ URL url = null;
+ try {
+ url = getURL(
+ b.min.east(), b.min.north(),
+ b.max.east(), b.max.north(),
+ width(), height());
+ request.finish(State.IMAGE, grab(url));
+
+ } catch(Exception e) {
+ e.printStackTrace();
+ throw new Exception(e.getMessage() + "\nImage couldn't be fetched: " + (url != null ? url.toString() : ""));
+ }
+ }
+
+ public static final NumberFormat latLonFormat = new DecimalFormat("###0.0000000",
+ new DecimalFormatSymbols(Locale.US));
+
+ protected URL getURL(double w, double s,double e,double n,
+ int wi, int ht) throws MalformedURLException {
+ String myProj = Main.proj.toCode();
+ if(Main.proj instanceof Mercator) // don't use mercator code directly
+ {
+ LatLon sw = Main.proj.eastNorth2latlon(new EastNorth(w, s));
+ LatLon ne = Main.proj.eastNorth2latlon(new EastNorth(e, n));
+ myProj = "EPSG:4326";
+ s = sw.lat();
+ w = sw.lon();
+ n = ne.lat();
+ e = ne.lon();
+ }
+
+ String str = baseURL;
+ String bbox = latLonFormat.format(w) + ","
+ + latLonFormat.format(s) + ","
+ + latLonFormat.format(e) + ","
+ + latLonFormat.format(n);
+
+ if (urlWithPatterns) {
+ str = str.replaceAll("\\{proj\\}", myProj)
+ .replaceAll("\\{bbox\\}", bbox)
+ .replaceAll("\\{w\\}", latLonFormat.format(w))
+ .replaceAll("\\{s\\}", latLonFormat.format(s))
+ .replaceAll("\\{e\\}", latLonFormat.format(e))
+ .replaceAll("\\{n\\}", latLonFormat.format(n))
+ .replaceAll("\\{width\\}", String.valueOf(wi))
+ .replaceAll("\\{height\\}", String.valueOf(ht));
+ } else {
+ str += "bbox=" + bbox
+ + getProjection(baseURL, false)
+ + "&width=" + wi + "&height=" + ht;
+ if (!(baseURL.endsWith("&") || baseURL.endsWith("?"))) {
+ System.out.println(tr("Warning: The base URL ''{0}'' for a WMS service doesn't have a trailing '&' or a trailing '?'.", baseURL));
+ System.out.println(tr("Warning: Fetching WMS tiles is likely to fail. Please check you preference settings."));
+ System.out.println(tr("Warning: The complete URL is ''{0}''.", str));
+ }
+ }
+ return new URL(str.replace(" ", "%20"));
+ }
+
+ static public String getProjection(String baseURL, Boolean warn)
+ {
+ String projname = Main.proj.toCode();
+ if(Main.proj instanceof Mercator) // don't use mercator code
+ projname = "EPSG:4326";
+ String res = "";
+ try
+ {
+ Matcher m = Pattern.compile(".*srs=([a-z0-9:]+).*").matcher(baseURL.toLowerCase());
+ if(m.matches())
+ {
+ projname = projname.toLowerCase();
+ if(!projname.equals(m.group(1)) && warn)
+ {
+ JOptionPane.showMessageDialog(Main.parent,
+ tr("The projection ''{0}'' in URL and current projection ''{1}'' mismatch.\n"
+ + "This may lead to wrong coordinates.",
+ m.group(1), projname),
+ tr("Warning"),
+ JOptionPane.WARNING_MESSAGE);
+ }
+ }
+ else
+ res ="&srs="+projname;
+ }
+ catch(Exception e)
+ {
+ }
+ return res;
+ }
+
+ @Override
+ public boolean loadFromCache(WMSRequest request) {
+ URL url = null;
+ try{
+ url = getURL(
+ b.min.east(), b.min.north(),
+ b.max.east(), b.max.north(),
+ width(), height());
+ } catch(Exception e) {
+ return false;
+ }
+ BufferedImage cached = cache.getImg(url.toString());
+ if((!request.isReal() && !layer.hasAutoDownload()) || cached != null){
+ if(cached == null){
+ request.finish(State.NOT_IN_CACHE, null);
+ return true;
+ }
+ request.finish(State.IMAGE, cached);
+ return true;
+ }
+ return false;
+ }
+
+ protected BufferedImage grab(URL url) throws IOException, OsmTransferException {
+ System.out.println("Grabbing WMS " + url);
+
+ HttpURLConnection conn = (HttpURLConnection) url.openConnection();
+ if(layer.info.getCookies() != null && !layer.info.getCookies().equals(""))
+ conn.setRequestProperty("Cookie", layer.info.getCookies());
+ conn.setRequestProperty("User-Agent", Main.pref.get("wmsplugin.user_agent", Version.getInstance().getAgentString()));
+ conn.setConnectTimeout(Main.pref.getInteger("wmsplugin.timeout.connect", 30) * 1000);
+ conn.setReadTimeout(Main.pref.getInteger("wmsplugin.timeout.read", 30) * 1000);
+
+ String contentType = conn.getHeaderField("Content-Type");
+ if( conn.getResponseCode() != 200
+ || contentType != null && !contentType.startsWith("image") ) {
+ throw new IOException(readException(conn));
+ }
+
+ InputStream is = new ProgressInputStream(conn, null);
+ BufferedImage img = ImageIO.read(is);
+ is.close();
+
+ cache.saveImg(url.toString(), img);
+ return img;
+ }
+
+ protected String readException(URLConnection conn) throws IOException {
+ StringBuilder exception = new StringBuilder();
+ InputStream in = conn.getInputStream();
+ BufferedReader br = new BufferedReader(new InputStreamReader(in));
+
+ String line = null;
+ while( (line = br.readLine()) != null) {
+ // filter non-ASCII characters and control characters
+ exception.append(line.replaceAll("[^\\p{Print}]", ""));
+ exception.append('\n');
+ }
+ return exception.toString();
+ }
+}
Index: applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/wms/WMSLayer.java
===================================================================
--- applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/wms/WMSLayer.java (revision 24501)
+++ applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/wms/WMSLayer.java (revision 24501)
@@ -0,0 +1,787 @@
+package org.openstreetmap.josm.plugins.imagery.wms;
+
+import static org.openstreetmap.josm.tools.I18n.tr;
+
+import java.awt.Component;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.event.ActionEvent;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+import javax.swing.AbstractAction;
+import javax.swing.Action;
+import javax.swing.JCheckBoxMenuItem;
+import javax.swing.JFileChooser;
+import javax.swing.JOptionPane;
+
+import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.actions.DiskAccessAction;
+import org.openstreetmap.josm.actions.SaveActionBase;
+import org.openstreetmap.josm.data.Bounds;
+import org.openstreetmap.josm.data.Preferences.PreferenceChangeEvent;
+import org.openstreetmap.josm.data.Preferences.PreferenceChangedListener;
+import org.openstreetmap.josm.data.ProjectionBounds;
+import org.openstreetmap.josm.data.coor.EastNorth;
+import org.openstreetmap.josm.data.osm.visitor.BoundingXYVisitor;
+import org.openstreetmap.josm.data.preferences.BooleanProperty;
+import org.openstreetmap.josm.gui.MapView;
+import org.openstreetmap.josm.gui.dialogs.LayerListDialog;
+import org.openstreetmap.josm.gui.dialogs.LayerListPopup;
+import org.openstreetmap.josm.gui.layer.Layer;
+import org.openstreetmap.josm.io.CacheFiles;
+import org.openstreetmap.josm.plugins.imagery.ImageryInfo;
+import org.openstreetmap.josm.plugins.imagery.ImageryInfo.ImageryType;
+import org.openstreetmap.josm.plugins.imagery.ImageryLayer;
+import org.openstreetmap.josm.plugins.imagery.ImageryPlugin;
+import org.openstreetmap.josm.plugins.imagery.wms.GeorefImage.State;
+import org.openstreetmap.josm.tools.ImageProvider;
+
+/**
+ * This is a layer that grabs the current screen from an WMS server. The data
+ * fetched this way is tiled and managed to the disc to reduce server load.
+ */
+public class WMSLayer extends ImageryLayer implements PreferenceChangedListener {
+
+ public static final BooleanProperty PROP_ALPHA_CHANNEL = new BooleanProperty("wmsplugin.alpha_channel", true);
+ WMSAdapter plugin = ImageryPlugin.wmsAdapter;
+
+ public int messageNum = 5; //limit for messages per layer
+ protected String resolution;
+ protected int imageSize = 500;
+ protected int dax = 10;
+ protected int day = 10;
+ protected int daStep = 5;
+ protected int minZoom = 3;
+
+ protected GeorefImage[][] images;
+ protected final int serializeFormatVersion = 5;
+ protected boolean autoDownloadEnabled = true;
+ protected boolean settingsChanged;
+ protected ImageryInfo info;
+
+ // Image index boundary for current view
+ private volatile int bminx;
+ private volatile int bminy;
+ private volatile int bmaxx;
+ private volatile int bmaxy;
+ private volatile int leftEdge;
+ private volatile int bottomEdge;
+
+ // Request queue
+ private final List requestQueue = new ArrayList();
+ private final List finishedRequests = new ArrayList();
+ private final Lock requestQueueLock = new ReentrantLock();
+ private final Condition queueEmpty = requestQueueLock.newCondition();
+ private final List grabbers = new ArrayList();
+ private final List grabberThreads = new ArrayList();
+ private int threadCount;
+ private int workingThreadCount;
+ private boolean canceled;
+
+
+ /** set to true if this layer uses an invalid base url */
+ private boolean usesInvalidUrl = false;
+ /** set to true if the user confirmed to use an potentially invalid WMS base url */
+ private boolean isInvalidUrlConfirmed = false;
+
+ public WMSLayer() {
+ this(new ImageryInfo(tr("Blank Layer")));
+ }
+
+ public WMSLayer(ImageryInfo info) {
+ super(info.getName());
+ setBackgroundLayer(true); /* set global background variable */
+ initializeImages();
+ this.info = new ImageryInfo(info);
+ mv = Main.map.mapView;
+ if(this.info.getPixelPerDegree() == 0.0)
+ this.info.setPixelPerDegree(getPPD());
+ resolution = mv.getDist100PixelText();
+
+ if(info.getURL() != null) {
+ WMSGrabber.getProjection(info.getURL(), true);
+ startGrabberThreads();
+ if(info.getImageryType() == ImageryType.WMS && !WMSGrabber.isUrlWithPatterns(info.getURL())) {
+ if (!(info.getURL().endsWith("&") || info.getURL().endsWith("?"))) {
+ if (!confirmMalformedUrl(info.getURL())) {
+ System.out.println(tr("Warning: WMS layer deactivated because of malformed base url ''{0}''", info.getURL()));
+ usesInvalidUrl = true;
+ setName(getName() + tr("(deactivated)"));
+ return;
+ } else {
+ isInvalidUrlConfirmed = true;
+ }
+ }
+ }
+ }
+
+ Main.pref.addPreferenceChangeListener(this);
+ }
+
+ public void doSetName(String name) {
+ setName(name);
+ info.setName(name);
+ }
+
+ public boolean hasAutoDownload(){
+ return autoDownloadEnabled;
+ }
+
+
+ @Override
+ public void destroy() {
+ cancelGrabberThreads(false);
+ Main.pref.removePreferenceChangeListener(this);
+ }
+
+ public void initializeImages() {
+ GeorefImage[][] old = images;
+ images = new GeorefImage[dax][day];
+ if (old != null) {
+ for (int i=0; i= 0 ? a%b : a%b+b;
+ }
+
+ private boolean zoomIsTooBig() {
+ //don't download when it's too outzoomed
+ return info.getPixelPerDegree() / getPPD() > minZoom;
+ }
+
+ @Override public void paint(Graphics2D g, final MapView mv, Bounds b) {
+ if(info.getURL() == null || (usesInvalidUrl && !isInvalidUrlConfirmed)) return;
+
+ settingsChanged = false;
+
+ ProjectionBounds bounds = mv.getProjectionBounds();
+ bminx= getImageXIndex(bounds.min.east());
+ bminy= getImageYIndex(bounds.min.north());
+ bmaxx= getImageXIndex(bounds.max.east());
+ bmaxy= getImageYIndex(bounds.max.north());
+
+ leftEdge = (int)(bounds.min.east() * getPPD());
+ bottomEdge = (int)(bounds.min.north() * getPPD());
+
+ if (zoomIsTooBig()) {
+ for(int x = bminx; x<=bmaxx; ++x) {
+ for(int y = bminy; y<=bmaxy; ++y) {
+ images[modulo(x,dax)][modulo(y,day)].paint(g, mv, x, y, leftEdge, bottomEdge);
+ }
+ }
+ } else {
+ downloadAndPaintVisible(g, mv, false);
+ }
+ }
+
+ protected boolean confirmMalformedUrl(String url) {
+ if (isInvalidUrlConfirmed)
+ return true;
+ String msg = tr("The base URL
"
+ + "''{0}''
"
+ + "for this WMS layer does neither end with a ''&'' nor with a ''?''.
"
+ + "This is likely to lead to invalid WMS request. You should check your
"
+ + "preference settings.
"
+ + "Do you want to fetch WMS tiles anyway?",
+ url);
+ String [] options = new String[] {
+ tr("Yes, fetch images"),
+ tr("No, abort")
+ };
+ int ret = JOptionPane.showOptionDialog(
+ Main.parent,
+ msg,
+ tr("Invalid URL?"),
+ JOptionPane.YES_NO_OPTION,
+ JOptionPane.WARNING_MESSAGE,
+ null,
+ options, options[1]
+ );
+ switch(ret) {
+ case JOptionPane.YES_OPTION: return true;
+ default: return false;
+ }
+ }
+
+ @Override
+ public void displace(double dx, double dy) {
+ super.displace(dx, dy);
+ settingsChanged = true;
+ }
+
+ public int getImageXIndex(double coord) {
+ return (int)Math.floor( ((coord - dx) * info.getPixelPerDegree()) / imageSize);
+ }
+
+ public int getImageYIndex(double coord) {
+ return (int)Math.floor( ((coord - dy) * info.getPixelPerDegree()) / imageSize);
+ }
+
+ public int getImageX(int imageIndex) {
+ return (int)(imageIndex * imageSize * (getPPD() / info.getPixelPerDegree()) + dx * getPPD());
+ }
+
+ public int getImageY(int imageIndex) {
+ return (int)(imageIndex * imageSize * (getPPD() / info.getPixelPerDegree()) + dy * getPPD());
+ }
+
+ public int getImageWidth(int xIndex) {
+ int overlap = (int)(plugin.PROP_OVERLAP.get()?plugin.PROP_OVERLAP_EAST.get() * imageSize * getPPD() / info.getPixelPerDegree() / 100:0);
+ return getImageX(xIndex + 1) - getImageX(xIndex) + overlap;
+ }
+
+ public int getImageHeight(int yIndex) {
+ int overlap = (int)(plugin.PROP_OVERLAP.get()?plugin.PROP_OVERLAP_NORTH.get() * imageSize * getPPD() / info.getPixelPerDegree() / 100:0);
+ return getImageY(yIndex + 1) - getImageY(yIndex) + overlap;
+ }
+
+ /**
+ *
+ * @return Size of image in original zoom
+ */
+ public int getBaseImageWidth() {
+ int overlap = (plugin.PROP_OVERLAP.get()?plugin.PROP_OVERLAP_EAST.get() * imageSize / 100:0);
+ return imageSize + overlap;
+ }
+
+ /**
+ *
+ * @return Size of image in original zoom
+ */
+ public int getBaseImageHeight() {
+ int overlap = (plugin.PROP_OVERLAP.get()?plugin.PROP_OVERLAP_NORTH.get() * imageSize / 100:0);
+ return imageSize + overlap;
+ }
+
+
+ /**
+ *
+ * @param xIndex
+ * @param yIndex
+ * @return Real EastNorth of given tile. dx/dy is not counted in
+ */
+ public EastNorth getEastNorth(int xIndex, int yIndex) {
+ return new EastNorth((xIndex * imageSize) / info.getPixelPerDegree(), (yIndex * imageSize) / info.getPixelPerDegree());
+ }
+
+
+ protected void downloadAndPaintVisible(Graphics g, final MapView mv, boolean real){
+
+ int newDax = dax;
+ int newDay = day;
+
+ if (bmaxx - bminx >= dax || bmaxx - bminx < dax - 2 * daStep) {
+ newDax = ((bmaxx - bminx) / daStep + 1) * daStep;
+ }
+
+ if (bmaxy - bminy >= day || bmaxy - bminx < day - 2 * daStep) {
+ newDay = ((bmaxy - bminy) / daStep + 1) * daStep;
+ }
+
+ if (newDax != dax || newDay != day) {
+ dax = newDax;
+ day = newDay;
+ initializeImages();
+ }
+
+ for(int x = bminx; x<=bmaxx; ++x) {
+ for(int y = bminy; y<=bmaxy; ++y){
+ images[modulo(x,dax)][modulo(y,day)].changePosition(x, y);
+ }
+ }
+
+ gatherFinishedRequests();
+
+ for(int x = bminx; x<=bmaxx; ++x) {
+ for(int y = bminy; y<=bmaxy; ++y){
+ GeorefImage img = images[modulo(x,dax)][modulo(y,day)];
+ if (!img.paint(g, mv, x, y, leftEdge, bottomEdge)) {
+ WMSRequest request = new WMSRequest(x, y, info.getPixelPerDegree(), real);
+ addRequest(request);
+ }
+ }
+ }
+ }
+
+ @Override public void visitBoundingBox(BoundingXYVisitor v) {
+ for(int x = 0; x more important request)
+ */
+ private int getRequestPriority(WMSRequest request) {
+ if (request.getPixelPerDegree() != info.getPixelPerDegree()) {
+ return -1;
+ }
+ if (bminx > request.getXIndex()
+ || bmaxx < request.getXIndex()
+ || bminy > request.getYIndex()
+ || bmaxy < request.getYIndex()) {
+ return -1;
+ }
+
+ EastNorth cursorEastNorth = mv.getEastNorth(mv.lastMEvent.getX(), mv.lastMEvent.getY());
+ int mouseX = getImageXIndex(cursorEastNorth.east());
+ int mouseY = getImageYIndex(cursorEastNorth.north());
+ int dx = request.getXIndex() - mouseX;
+ int dy = request.getYIndex() - mouseY;
+
+ return dx * dx + dy * dy;
+ }
+
+ public WMSRequest getRequest() {
+ requestQueueLock.lock();
+ try {
+ workingThreadCount--;
+ Iterator it = requestQueue.iterator();
+ while (it.hasNext()) {
+ WMSRequest item = it.next();
+ int priority = getRequestPriority(item);
+ if (priority == -1) {
+ it.remove();
+ } else {
+ item.setPriority(priority);
+ }
+ }
+ Collections.sort(requestQueue);
+
+ EastNorth cursorEastNorth = mv.getEastNorth(mv.lastMEvent.getX(), mv.lastMEvent.getY());
+ int mouseX = getImageXIndex(cursorEastNorth.east());
+ int mouseY = getImageYIndex(cursorEastNorth.north());
+ boolean isOnMouse = requestQueue.size() > 0 && requestQueue.get(0).getXIndex() == mouseX && requestQueue.get(0).getYIndex() == mouseY;
+
+ // If there is only one thread left then keep it in case we need to download other tile urgently
+ while (!canceled &&
+ (requestQueue.isEmpty() || (!isOnMouse && threadCount - workingThreadCount == 0 && threadCount > 1))) {
+ try {
+ queueEmpty.await();
+ } catch (InterruptedException e) {
+ // Shouldn't happen
+ }
+ }
+
+ workingThreadCount++;
+ if (canceled) {
+ return null;
+ } else {
+ return requestQueue.remove(0);
+ }
+
+ } finally {
+ requestQueueLock.unlock();
+ }
+ }
+
+ public void finishRequest(WMSRequest request) {
+ if (request.getState() == null) {
+ throw new IllegalArgumentException("Finished request without state");
+ }
+ requestQueueLock.lock();
+ try {
+ finishedRequests.add(request);
+ } finally {
+ requestQueueLock.unlock();
+ }
+ }
+
+ public void addRequest(WMSRequest request) {
+ requestQueueLock.lock();
+ try {
+ if (!requestQueue.contains(request)) {
+ requestQueue.add(request);
+ queueEmpty.signalAll();
+ }
+ } finally {
+ requestQueueLock.unlock();
+ }
+ }
+
+ public boolean requestIsValid(WMSRequest request) {
+ return bminx <= request.getXIndex() && bmaxx >= request.getXIndex() && bminy <= request.getYIndex() && bmaxy >= request.getYIndex();
+ }
+
+ private void gatherFinishedRequests() {
+ requestQueueLock.lock();
+ try {
+ for (WMSRequest request: finishedRequests) {
+ GeorefImage img = images[modulo(request.getXIndex(),dax)][modulo(request.getYIndex(),day)];
+ if (img.equalPosition(request.getXIndex(), request.getYIndex())) {
+ img.changeImage(request.getState(), request.getImage());
+ }
+ }
+ } finally {
+ finishedRequests.clear();
+ requestQueueLock.unlock();
+ }
+ }
+
+ public class DownloadAction extends AbstractAction {
+ private static final long serialVersionUID = -7183852461015284020L;
+ public DownloadAction() {
+ super(tr("Download visible tiles"));
+ }
+ @Override
+ public void actionPerformed(ActionEvent ev) {
+ if (zoomIsTooBig()) {
+ JOptionPane.showMessageDialog(
+ Main.parent,
+ tr("The requested area is too big. Please zoom in a little, or change resolution"),
+ tr("Error"),
+ JOptionPane.ERROR_MESSAGE
+ );
+ } else {
+ downloadAndPaintVisible(mv.getGraphics(), mv, true);
+ }
+ }
+ }
+
+ public class ChangeResolutionAction extends AbstractAction {
+ public ChangeResolutionAction() {
+ super(tr("Change resolution"));
+ }
+ @Override
+ public void actionPerformed(ActionEvent ev) {
+ initializeImages();
+ resolution = mv.getDist100PixelText();
+ info.setPixelPerDegree(getPPD());
+ settingsChanged = true;
+ mv.repaint();
+ }
+ }
+
+ public class ReloadErrorTilesAction extends AbstractAction {
+ public ReloadErrorTilesAction() {
+ super(tr("Reload erroneous tiles"));
+ }
+ @Override
+ public void actionPerformed(ActionEvent ev) {
+ // Delete small files, because they're probably blank tiles.
+ // See https://josm.openstreetmap.de/ticket/2307
+ plugin.cache.customCleanUp(CacheFiles.CLEAN_SMALL_FILES, 4096);
+
+ for (int x = 0; x < dax; ++x) {
+ for (int y = 0; y < day; ++y) {
+ GeorefImage img = images[modulo(x,dax)][modulo(y,day)];
+ if(img.getState() == State.FAILED){
+ addRequest(new WMSRequest(img.getXIndex(), img.getYIndex(), info.getPixelPerDegree(), true));
+ mv.repaint();
+ }
+ }
+ }
+ }
+ }
+
+ public class ToggleAlphaAction extends AbstractAction implements LayerAction {
+ public ToggleAlphaAction() {
+ super(tr("Alpha channel"));
+ }
+ @Override
+ public void actionPerformed(ActionEvent ev) {
+ JCheckBoxMenuItem checkbox = (JCheckBoxMenuItem) ev.getSource();
+ boolean alphaChannel = checkbox.isSelected();
+ PROP_ALPHA_CHANNEL.put(alphaChannel);
+
+ // clear all resized cached instances and repaint the layer
+ for (int x = 0; x < dax; ++x) {
+ for (int y = 0; y < day; ++y) {
+ GeorefImage img = images[modulo(x, dax)][modulo(y, day)];
+ img.flushedResizedCachedInstance();
+ }
+ }
+ mv.repaint();
+ }
+ @Override
+ public Component createMenuComponent() {
+ JCheckBoxMenuItem item = new JCheckBoxMenuItem(this);
+ item.setSelected(PROP_ALPHA_CHANNEL.get());
+ return item;
+ }
+ @Override
+ public boolean supportLayers(List layers) {
+ return layers.size() == 1 && layers.get(0) instanceof WMSLayer;
+ }
+ }
+
+ public class SaveWmsAction extends AbstractAction {
+ public SaveWmsAction() {
+ super(tr("Save WMS layer to file"), ImageProvider.get("save"));
+ }
+ @Override
+ public void actionPerformed(ActionEvent ev) {
+ File f = SaveActionBase.createAndOpenSaveFileChooser(
+ tr("Save WMS layer"), ".wms");
+ try {
+ if (f != null) {
+ ObjectOutputStream oos = new ObjectOutputStream(
+ new FileOutputStream(f)
+ );
+ oos.writeInt(serializeFormatVersion);
+ oos.writeInt(dax);
+ oos.writeInt(day);
+ oos.writeInt(imageSize);
+ oos.writeDouble(info.getPixelPerDegree());
+ oos.writeObject(info.getName());
+ oos.writeObject(info.getFullURL());
+ oos.writeObject(images);
+ oos.close();
+ }
+ } catch (Exception ex) {
+ ex.printStackTrace(System.out);
+ }
+ }
+ }
+
+ public class LoadWmsAction extends AbstractAction {
+ public LoadWmsAction() {
+ super(tr("Load WMS layer from file"), ImageProvider.get("load"));
+ }
+ @Override
+ public void actionPerformed(ActionEvent ev) {
+ JFileChooser fc = DiskAccessAction.createAndOpenFileChooser(true,
+ false, tr("Load WMS layer"), "wms");
+ if(fc == null) return;
+ File f = fc.getSelectedFile();
+ if (f == null) return;
+ try
+ {
+ FileInputStream fis = new FileInputStream(f);
+ ObjectInputStream ois = new ObjectInputStream(fis);
+ int sfv = ois.readInt();
+ if (sfv != serializeFormatVersion) {
+ JOptionPane.showMessageDialog(Main.parent,
+ tr("Unsupported WMS file version; found {0}, expected {1}", sfv, serializeFormatVersion),
+ tr("File Format Error"),
+ JOptionPane.ERROR_MESSAGE);
+ return;
+ }
+ autoDownloadEnabled = false;
+ dax = ois.readInt();
+ day = ois.readInt();
+ imageSize = ois.readInt();
+ info.setPixelPerDegree(ois.readDouble());
+ doSetName((String)ois.readObject());
+ info.setURL((String) ois.readObject());
+ images = (GeorefImage[][])ois.readObject();
+ ois.close();
+ fis.close();
+ for (GeorefImage[] imgs : images) {
+ for (GeorefImage img : imgs) {
+ if (img != null) {
+ img.setLayer(WMSLayer.this);
+ }
+ }
+ }
+ settingsChanged = true;
+ mv.repaint();
+ if(info.getURL() != null)
+ {
+ startGrabberThreads();
+ }
+ }
+ catch (Exception ex) {
+ // FIXME be more specific
+ ex.printStackTrace(System.out);
+ JOptionPane.showMessageDialog(Main.parent,
+ tr("Error loading file"),
+ tr("Error"),
+ JOptionPane.ERROR_MESSAGE);
+ return;
+ }
+ }
+ }
+ /**
+ * This action will add a WMS layer menu entry with the current WMS layer
+ * URL and name extended by the current resolution.
+ * When using the menu entry again, the WMS cache will be used properly.
+ */
+ public class BookmarkWmsAction extends AbstractAction {
+ public BookmarkWmsAction() {
+ super(tr("Set WMS Bookmark"));
+ }
+ @Override
+ public void actionPerformed(ActionEvent ev) {
+ ImageryPlugin.instance.addLayer(new ImageryInfo(info));
+ }
+ }
+
+ private class StartStopAction extends AbstractAction implements LayerAction {
+
+ public StartStopAction() {
+ super(tr("Automatic downloading"));
+ }
+
+ @Override
+ public Component createMenuComponent() {
+ JCheckBoxMenuItem item = new JCheckBoxMenuItem(this);
+ item.setSelected(autoDownloadEnabled);
+ return item;
+ }
+
+ @Override
+ public boolean supportLayers(List layers) {
+ return layers.size() == 1 && layers.get(0) instanceof WMSLayer;
+ }
+
+ @Override
+ public void actionPerformed(ActionEvent e) {
+ autoDownloadEnabled = !autoDownloadEnabled;
+ if (autoDownloadEnabled) {
+ mv.repaint();
+ }
+ }
+ }
+
+ private void cancelGrabberThreads(boolean wait) {
+ requestQueueLock.lock();
+ try {
+ canceled = true;
+ for (Grabber grabber: grabbers) {
+ grabber.cancel();
+ }
+ queueEmpty.signalAll();
+ } finally {
+ requestQueueLock.unlock();
+ }
+ if (wait) {
+ for (Thread t: grabberThreads) {
+ try {
+ t.join();
+ } catch (InterruptedException e) {
+ // Shouldn't happen
+ e.printStackTrace();
+ }
+ }
+ }
+ }
+
+ private void startGrabberThreads() {
+ int threadCount = plugin.PROP_SIMULTANEOUS_CONNECTIONS.get();
+ requestQueueLock.lock();
+ try {
+ canceled = false;
+ grabbers.clear();
+ grabberThreads.clear();
+ for (int i=0; i" + args.get("url");
+ }
+
+ @Override
+ public PermissionPrefWithDefault getPermissionPref()
+ {
+ return new PermissionPrefWithDefault(
+ "wmsplugin.remotecontrol",
+ true,
+ "RemoteControl: WMS forbidden by preferences");
+ }
+
+ @Override
+ protected String[] getMandatoryParams()
+ {
+ return new String[] { "url" };
+ }
+
+ @Override
+ protected void handleRequest() throws RequestHandlerErrorException {
+ String url = args.get("url");
+ String title = args.get("title");
+ if((title == null) || (title.length() == 0))
+ {
+ title = tr("Remote WMS");
+ }
+ String cookies = args.get("cookies");
+ WMSLayer wmsLayer = new WMSLayer(new ImageryInfo(title, url, cookies));
+ Main.main.addLayer(wmsLayer);
+
+ }
+
+ @Override
+ public void parseArgs() {
+ StringTokenizer st = new StringTokenizer(request, "&?");
+ HashMap args = new HashMap();
+ // skip first element which is the command
+ if(st.hasMoreTokens()) st.nextToken();
+ while (st.hasMoreTokens()) {
+ String param = st.nextToken();
+ int eq = param.indexOf("=");
+ if (eq > -1)
+ {
+ String key = param.substring(0, eq);
+ /* "url=" terminates normal parameters
+ * and will be handled separately
+ */
+ if("url".equals(key)) break;
+
+ String value = param.substring(eq + 1);
+ // urldecode all normal values
+ try {
+ value = URLDecoder.decode(value, "UTF-8");
+ } catch (UnsupportedEncodingException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ args.put(key,
+ value);
+ }
+ }
+ // url as second or later parameter
+ int urlpos = request.indexOf("&url=");
+ // url as first (and only) parameter
+ if(urlpos < 0) urlpos = request.indexOf("?url=");
+ // url found?
+ if(urlpos >= 0) {
+ // URL value
+ String value = request.substring(urlpos + 5);
+ // allow skipping URL decoding with urldecode=false
+ String urldecode = args.get("urldecode");
+ if((urldecode == null) || (Boolean.valueOf(urldecode) == true))
+ {
+ try {
+ value = URLDecoder.decode(value, "UTF-8");
+ } catch (UnsupportedEncodingException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ }
+ args.put("url", value);
+ }
+ this.args = args;
+ }
+}
Index: applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/wms/WMSRequest.java
===================================================================
--- applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/wms/WMSRequest.java (revision 24501)
+++ applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/wms/WMSRequest.java (revision 24501)
@@ -0,0 +1,102 @@
+package org.openstreetmap.josm.plugins.imagery.wms;
+
+import java.awt.image.BufferedImage;
+
+import org.openstreetmap.josm.plugins.imagery.wms.GeorefImage.State;
+
+public class WMSRequest implements Comparable {
+ private final int xIndex;
+ private final int yIndex;
+ private final double pixelPerDegree;
+ private final boolean real; // Download even if autodownloading is disabled
+ private int priority;
+ // Result
+ private State state;
+ private BufferedImage image;
+
+ public WMSRequest(int xIndex, int yIndex, double pixelPerDegree, boolean real) {
+ this.xIndex = xIndex;
+ this.yIndex = yIndex;
+ this.pixelPerDegree = pixelPerDegree;
+ this.real = real;
+ }
+
+ public void finish(State state, BufferedImage image) {
+ this.state = state;
+ this.image = image;
+ }
+
+ public int getXIndex() {
+ return xIndex;
+ }
+
+ public int getYIndex() {
+ return yIndex;
+ }
+
+ public double getPixelPerDegree() {
+ return pixelPerDegree;
+ }
+
+ @Override
+ public int hashCode() {
+ final int prime = 31;
+ int result = 1;
+ long temp;
+ temp = Double.doubleToLongBits(pixelPerDegree);
+ result = prime * result + (int) (temp ^ (temp >>> 32));
+ result = prime * result + xIndex;
+ result = prime * result + yIndex;
+ return result;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj)
+ return true;
+ if (obj == null)
+ return false;
+ if (getClass() != obj.getClass())
+ return false;
+ WMSRequest other = (WMSRequest) obj;
+ if (Double.doubleToLongBits(pixelPerDegree) != Double
+ .doubleToLongBits(other.pixelPerDegree))
+ return false;
+ if (xIndex != other.xIndex)
+ return false;
+ if (yIndex != other.yIndex)
+ return false;
+ return true;
+ }
+
+ public void setPriority(int priority) {
+ this.priority = priority;
+ }
+
+ public int getPriority() {
+ return priority;
+ }
+
+ @Override
+ public int compareTo(WMSRequest o) {
+ return priority - o.priority;
+ }
+
+ public State getState() {
+ return state;
+ }
+
+ public BufferedImage getImage() {
+ return image;
+ }
+
+ @Override
+ public String toString() {
+ return "WMSRequest [xIndex=" + xIndex + ", yIndex=" + yIndex
+ + ", pixelPerDegree=" + pixelPerDegree + "]";
+ }
+
+ public boolean isReal() {
+ return real;
+ }
+}
Index: applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/wms/io/WMSLayerExporter.java
===================================================================
--- applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/wms/io/WMSLayerExporter.java (revision 24501)
+++ applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/wms/io/WMSLayerExporter.java (revision 24501)
@@ -0,0 +1,13 @@
+package org.openstreetmap.josm.plugins.imagery.wms.io;
+
+import static org.openstreetmap.josm.tools.I18n.tr;
+
+import org.openstreetmap.josm.actions.ExtensionFileFilter;
+import org.openstreetmap.josm.io.FileExporter;
+
+public class WMSLayerExporter extends FileExporter{
+
+ public WMSLayerExporter() {
+ super(new ExtensionFileFilter("wms", "wms", tr("WMS Files (*.wms)")));
+ }
+}
Index: applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/wms/io/WMSLayerImporter.java
===================================================================
--- applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/wms/io/WMSLayerImporter.java (revision 24501)
+++ applications/editors/josm/plugins/imagery/src/org/openstreetmap/josm/plugins/imagery/wms/io/WMSLayerImporter.java (revision 24501)
@@ -0,0 +1,14 @@
+package org.openstreetmap.josm.plugins.imagery.wms.io;
+
+import static org.openstreetmap.josm.tools.I18n.tr;
+
+import org.openstreetmap.josm.actions.ExtensionFileFilter;
+import org.openstreetmap.josm.io.FileImporter;
+
+public class WMSLayerImporter extends FileImporter{
+
+ public WMSLayerImporter() {
+ super(new ExtensionFileFilter("wms", "wms", tr("WMS Files (*.wms)")));
+ }
+
+}