Changeset 13127 in josm

Timestamp:

2017-11-19T00:10:41+01:00 (7 years ago)

Author:

Don-vip

Message:

see #15476, fix #15511 - fix image scaling regression and makes geoimage feature more configurable through prefs (adjustable max zoom, zoom-step, click zooming with mouse buttons (e.g. if a mouse wheel is not present). Patch by cmuelle8

Location:

trunk

Files:

• src/org/openstreetmap/josm/gui/layer/geoimage/ImageDisplay.java (modified) (32 diffs)
• src/org/openstreetmap/josm/gui/layer/geoimage/ThumbsLoader.java (modified) (2 diffs)
• src/org/openstreetmap/josm/tools/ImageProvider.java (modified) (3 diffs)
• test/unit/org/openstreetmap/josm/gui/layer/geoimage/ImageDisplayTest.java (modified) (2 diffs)

trunk/src/org/openstreetmap/josm/gui/layer/geoimage/ImageDisplay.java

@@ -26 +26 @@
 
 import javax.swing.JComponent;
-
+import javax.swing.SwingUtilities;
+
+import org.openstreetmap.josm.data.preferences.BooleanProperty;
+import org.openstreetmap.josm.data.preferences.DoubleProperty;
 import org.openstreetmap.josm.spi.preferences.Config;
+import org.openstreetmap.josm.spi.preferences.PreferenceChangeEvent;
+import org.openstreetmap.josm.spi.preferences.PreferenceChangedListener;
 import org.openstreetmap.josm.tools.ExifReader;
 import org.openstreetmap.josm.tools.ImageProvider;
@@ -37 +42 @@
  * Offers basic mouse interaction (zoom, drag) and on-screen text.
  */
-public class ImageDisplay extends JComponent {
+public class ImageDisplay extends JComponent implements PreferenceChangedListener {
 
     /** The file that is currently displayed */
@@ -50 +55 @@
     /** The rectangle (in image coordinates) of the image that is visible. This rectangle is calculated
      * each time the zoom is modified */
-    private Rectangle visibleRect;
+    private VisRect visibleRect;
 
     /** When a selection is done, the rectangle of the selection (in image coordinates) */
-    private Rectangle selectedRect;
+    private VisRect selectedRect;
 
     /** The tracker to load the images */
@@ -60 +65 @@
     private String osdText;
 
-    private static final int DRAG_BUTTON = Config.getPref().getBoolean("geoimage.agpifo-style-drag-and-zoom", false) ? 1 : 3;
-    private static final int ZOOM_BUTTON = DRAG_BUTTON == 1 ? 3 : 1;
+    private static final BooleanProperty AGPIFO_STYLE2 =
+        new BooleanProperty("geoimage.agpifo-style-drag-and-zoom", false);
+    private static int DRAG_BUTTON;
+    private static int ZOOM_BUTTON;
+
+    /** Alternative to mouse wheel zoom; esp. handy if no mouse wheel is present **/
+    private static final BooleanProperty ZOOM_ON_CLICK =
+        new BooleanProperty("geoimage.use-mouse-clicks-to-zoom", true);
+
+    /** Zoom factor when click or wheel zooming **/
+    private static final DoubleProperty ZOOM_STEP =
+        new DoubleProperty("geoimage.zoom-step-factor", 3 / 2.0);
+
+    /** Maximum zoom allowed **/
+    private static final DoubleProperty MAX_ZOOM =
+        new DoubleProperty("geoimage.maximum-zoom-scale", 2.0);
+
+    /** Use bilinear filtering **/
+    private static final BooleanProperty BILIN_DOWNSAMP =
+        new BooleanProperty("geoimage.bilinear-downsampling-progressive", true);
+    private static final BooleanProperty BILIN_UPSAMP =
+        new BooleanProperty("geoimage.bilinear-upsampling", false);
+    private static double BILIN_UPPER;
+    private static double BILIN_LOWER;
+
+    @Override
+    public void preferenceChanged(PreferenceChangeEvent e) {
+        if (e == null ||
+            e.getKey().equals(AGPIFO_STYLE2.getKey()))
+        {
+            DRAG_BUTTON = AGPIFO_STYLE2.get() ? 1 : 3;
+            ZOOM_BUTTON = DRAG_BUTTON == 1 ? 3 : 1;
+        }
+        if (e == null ||
+            e.getKey().equals(MAX_ZOOM.getKey()) ||
+            e.getKey().equals(BILIN_DOWNSAMP.getKey()) ||
+            e.getKey().equals(BILIN_UPSAMP.getKey()))
+        {
+            BILIN_UPPER = (BILIN_UPSAMP.get() ? 2*MAX_ZOOM.get() : (BILIN_DOWNSAMP.get() ? 0.5 : 0));
+            BILIN_LOWER = (BILIN_DOWNSAMP.get() ? 0 : 1);
+        }
+    }
+
+    /** Manage the visible rectangle of an image with full bounds stored in init. **/
+    public static class VisRect extends Rectangle {
+        private final Rectangle init;
+
+        public VisRect(int x, int y, int width, int height) {
+            super(x, y, width, height);
+            init = new Rectangle(this);
+        }
+
+        public VisRect(int x, int y, int width, int height, VisRect peer) {
+            super(x, y, width, height);
+            init = peer.init;
+        }
+
+        public VisRect(VisRect v) {
+            super(v);
+            init = v.init;
+        }
+
+        public VisRect() {
+            this(0, 0, 0, 0);
+        }
+
+        public boolean isFullView() {
+            return init.equals(this);
+        }
+
+        public boolean isFullView1D() {
+            return (init.x == x && init.width == width)
+                || (init.y == y && init.height == height);
+        }
+
+        public void reset() {
+            setBounds(init);
+        }
+
+        public void checkRectPos() {
+            if (x < 0) {
+                x = 0;
+            }
+            if (y < 0) {
+                y = 0;
+            }
+            if (x + width > init.width) {
+                x = init.width - width;
+            }
+            if (y + height > init.height) {
+                y = init.height - height;
+            }
+        }
+
+        public void checkRectSize() {
+            if (width > init.width) {
+                width = init.width;
+            }
+            if (height > init.height) {
+                height = init.height;
+            }
+        }
+
+        public void checkPointInside(Point p) {
+            if (p.x < x) {
+                p.x = x;
+            }
+            if (p.x > x + width) {
+                p.x = x + width;
+            }
+            if (p.y < y) {
+                p.y = y;
+            }
+            if (p.y > y + height) {
+                p.y = y + height;
+            }
+        }
+    }
 
     /** The thread that reads the images. */
@@ -108 +229 @@
                 if (!error) {
                     ImageDisplay.this.image = img;
-                    visibleRect = new Rectangle(0, 0, img.getWidth(null), img.getHeight(null));
+                    visibleRect = new VisRect(0, 0, img.getWidth(null), img.getHeight(null));
 
                     final int w = (int) visibleRect.getWidth();
@@ -144 +265 @@
     private class ImgDisplayMouseListener implements MouseListener, MouseWheelListener, MouseMotionListener {
 
-        private boolean mouseIsDragging;
-        private long lastTimeForMousePoint;
+        private MouseEvent lastMouseEvent;
         private Point mousePointInImg;
 
-        /** Zoom in and out, trying to preserve the point of the image that was under the mouse cursor
-         * at the same place */
-        @Override
-        public void mouseWheelMoved(MouseWheelEvent e) {
+        private boolean mouseIsDragging(MouseEvent e) {
+            return (DRAG_BUTTON == 1 && SwingUtilities.isLeftMouseButton(e)) ||
+                   (DRAG_BUTTON == 2 && SwingUtilities.isMiddleMouseButton(e)) ||
+                   (DRAG_BUTTON == 3 && SwingUtilities.isRightMouseButton(e));
+        }
+
+        private boolean mouseIsZoomSelecting(MouseEvent e) {
+            return (ZOOM_BUTTON == 1 && SwingUtilities.isLeftMouseButton(e)) ||
+                   (ZOOM_BUTTON == 2 && SwingUtilities.isMiddleMouseButton(e)) ||
+                   (ZOOM_BUTTON == 3 && SwingUtilities.isRightMouseButton(e));
+        }
+
+        private boolean isAtMaxZoom(Rectangle visibleRect) {
+            return (visibleRect.width == (int) (getSize().width / MAX_ZOOM.get()) ||
+                    visibleRect.height == (int) (getSize().height / MAX_ZOOM.get()));
+        }
+
+        private void mouseWheelMovedImpl(int x, int y, int rotation, boolean refreshMousePointInImg) {
             File file;
             Image image;
-            Rectangle visibleRect;
+            VisRect visibleRect;
 
             synchronized (ImageDisplay.this) {
@@ -162 +296 @@
             }
 
-            mouseIsDragging = false;
             selectedRect = null;
 
@@ -168 +301 @@
                 return;
 
-            // Calculate the mouse cursor position in image coordinates, so that we can center the zoom
-            // on that mouse position.
-            // To avoid issues when the user tries to zoom in on the image borders, this point is not calculated
-            // again if there was less than 1.5seconds since the last event.
-            if (e.getWhen() - lastTimeForMousePoint > 1500 || mousePointInImg == null) {
-                lastTimeForMousePoint = e.getWhen();
-                mousePointInImg = comp2imgCoord(visibleRect, e.getX(), e.getY(), getSize());
-            }
-
-            // Applicate the zoom to the visible rectangle in image coordinates
-            if (e.getWheelRotation() > 0) {
-                visibleRect.width = visibleRect.width * 3 / 2;
-                visibleRect.height = visibleRect.height * 3 / 2;
+            // Calculate the mouse cursor position in image coordinates to center the zoom.
+            if (refreshMousePointInImg)
+                mousePointInImg = comp2imgCoord(visibleRect, x, y, getSize());
+
+            // Apply the zoom to the visible rectangle in image coordinates
+            if (rotation > 0) {
+                visibleRect.width = (int) (visibleRect.width * ZOOM_STEP.get());
+                visibleRect.height = (int) (visibleRect.height * ZOOM_STEP.get());
             } else {
-                visibleRect.width = visibleRect.width * 2 / 3;
-                visibleRect.height = visibleRect.height * 2 / 3;
-            }
-
-            // Check that the zoom doesn't exceed 2:1
-            if (visibleRect.width < getSize().width / 2) {
-                visibleRect.width = getSize().width / 2;
-            }
-            if (visibleRect.height < getSize().height / 2) {
-                visibleRect.height = getSize().height / 2;
+                visibleRect.width = (int) (visibleRect.width / ZOOM_STEP.get());
+                visibleRect.height = (int) (visibleRect.height / ZOOM_STEP.get());
+            }
+
+            // Check that the zoom doesn't exceed MAX_ZOOM:1
+            if (visibleRect.width < getSize().width / MAX_ZOOM.get()) {
+                visibleRect.width = (int) (getSize().width / MAX_ZOOM.get());
+            }
+            if (visibleRect.height < getSize().height / MAX_ZOOM.get()) {
+                visibleRect.height = (int) (getSize().height / MAX_ZOOM.get());
             }
 
@@ -204 +332 @@
 
             // The size of the visible rectangle is limited by the image size.
-            checkVisibleRectSize(image, visibleRect);
+            visibleRect.checkRectSize();
 
             // Set the position of the visible rectangle, so that the mouse cursor doesn't move on the image.
             Rectangle drawRect = calculateDrawImageRectangle(visibleRect, getSize());
-            visibleRect.x = mousePointInImg.x + ((drawRect.x - e.getX()) * visibleRect.width) / drawRect.width;
-            visibleRect.y = mousePointInImg.y + ((drawRect.y - e.getY()) * visibleRect.height) / drawRect.height;
+            visibleRect.x = mousePointInImg.x + ((drawRect.x - x) * visibleRect.width) / drawRect.width;
+            visibleRect.y = mousePointInImg.y + ((drawRect.y - y) * visibleRect.height) / drawRect.height;
 
             // The position is also limited by the image size
-            checkVisibleRectPos(image, visibleRect);
+            visibleRect.checkRectPos();
 
             synchronized (ImageDisplay.this) {
@@ -220 +348 @@
             }
             ImageDisplay.this.repaint();
+        }
+
+        /** Zoom in and out, trying to preserve the point of the image that was under the mouse cursor
+         * at the same place */
+        @Override
+        public void mouseWheelMoved(MouseWheelEvent e) {
+            boolean refreshMousePointInImg = false;
+
+            // To avoid issues when the user tries to zoom in on the image borders, this
+            // point is not recalculated as long as e occurs at roughly the same position.
+            if (lastMouseEvent == null || mousePointInImg == null ||
+                ((lastMouseEvent.getX()-e.getX())*(lastMouseEvent.getX()-e.getX())
+                +(lastMouseEvent.getY()-e.getY())*(lastMouseEvent.getY()-e.getY()) > 4*4)) {
+                lastMouseEvent = e;
+                refreshMousePointInImg = true;
+            }
+
+            mouseWheelMovedImpl(e.getX(), e.getY(), e.getWheelRotation(), refreshMousePointInImg);
         }
 
@@ -228 +374 @@
             File file;
             Image image;
-            Rectangle visibleRect;
+            VisRect visibleRect;
 
             synchronized (ImageDisplay.this) {
@@ -239 +385 @@
                 return;
 
-            if (e.getButton() != DRAG_BUTTON)
-                return;
+            if (ZOOM_ON_CLICK.get()) {
+                // click notions are less coherent than wheel, refresh mousePointInImg on each click
+                lastMouseEvent = null;
+
+                if (mouseIsZoomSelecting(e) && !isAtMaxZoom(visibleRect)) {
+                    // zoom in if clicked with the zoom button
+                    mouseWheelMovedImpl(e.getX(), e.getY(), -1, true);
+                    return;
+                }
+                if (mouseIsDragging(e)) {
+                    // zoom out if clicked with the drag button
+                    mouseWheelMovedImpl(e.getX(), e.getY(), 1, true);
+                    return;
+                }
+            }
 
             // Calculate the translation to set the clicked point the center of the view.
@@ -249 +408 @@
             visibleRect.y += click.y - center.y;
 
-            checkVisibleRectPos(image, visibleRect);
+            visibleRect.checkRectPos();
 
             synchronized (ImageDisplay.this) {
@@ -263 +422 @@
         @Override
         public void mousePressed(MouseEvent e) {
-            if (image == null) {
-                mouseIsDragging = false;
-                selectedRect = null;
-                return;
-            }
-
             Image image;
-            Rectangle visibleRect;
+            VisRect visibleRect;
 
             synchronized (ImageDisplay.this) {
@@ -280 +433 @@
                 return;
 
-            if (e.getButton() == DRAG_BUTTON) {
+            selectedRect = null;
+
+            if (mouseIsDragging(e) || mouseIsZoomSelecting(e))
                 mousePointInImg = comp2imgCoord(visibleRect, e.getX(), e.getY(), getSize());
-                mouseIsDragging = true;
-                selectedRect = null;
-            } else if (e.getButton() == ZOOM_BUTTON) {
-                mousePointInImg = comp2imgCoord(visibleRect, e.getX(), e.getY(), getSize());
-                checkPointInVisibleRect(mousePointInImg, visibleRect);
-                mouseIsDragging = false;
-                selectedRect = new Rectangle(mousePointInImg.x, mousePointInImg.y, 0, 0);
-                ImageDisplay.this.repaint();
-            } else {
-                mouseIsDragging = false;
-                selectedRect = null;
-            }
         }
 
         @Override
         public void mouseDragged(MouseEvent e) {
-            if (!mouseIsDragging && selectedRect == null)
+            if (!mouseIsDragging(e) && !mouseIsZoomSelecting(e))
                 return;
 
             File file;
             Image image;
-            Rectangle visibleRect;
+            VisRect visibleRect;
 
             synchronized (ImageDisplay.this) {
@@ -311 +454 @@
             }
 
-            if (image == null) {
-                mouseIsDragging = false;
-                selectedRect = null;
+            if (image == null)
                 return;
-            }
-
-            if (mouseIsDragging) {
+
+            if (mouseIsDragging(e)) {
                 Point p = comp2imgCoord(visibleRect, e.getX(), e.getY(), getSize());
                 visibleRect.x += mousePointInImg.x - p.x;
                 visibleRect.y += mousePointInImg.y - p.y;
-                checkVisibleRectPos(image, visibleRect);
+                visibleRect.checkRectPos();
                 synchronized (ImageDisplay.this) {
                     if (ImageDisplay.this.file == file) {
@@ -328 +468 @@
                 }
                 ImageDisplay.this.repaint();
-
-            } else if (selectedRect != null) {
+            }
+
+            if (mouseIsZoomSelecting(e)) {
                 Point p = comp2imgCoord(visibleRect, e.getX(), e.getY(), getSize());
-                checkPointInVisibleRect(p, visibleRect);
-                Rectangle rect = new Rectangle(
+                visibleRect.checkPointInside(p);
+                VisRect selectedRect = new VisRect(
                         p.x < mousePointInImg.x ? p.x : mousePointInImg.x,
                         p.y < mousePointInImg.y ? p.y : mousePointInImg.y,
                         p.x < mousePointInImg.x ? mousePointInImg.x - p.x : p.x - mousePointInImg.x,
-                        p.y < mousePointInImg.y ? mousePointInImg.y - p.y : p.y - mousePointInImg.y);
-                checkVisibleRectSize(image, rect);
-                checkVisibleRectPos(image, rect);
-                ImageDisplay.this.selectedRect = rect;
+                        p.y < mousePointInImg.y ? mousePointInImg.y - p.y : p.y - mousePointInImg.y,
+                        visibleRect);
+                selectedRect.checkRectSize();
+                selectedRect.checkRectPos();
+                ImageDisplay.this.selectedRect = selectedRect;
                 ImageDisplay.this.repaint();
             }
@@ -347 +489 @@
         @Override
         public void mouseReleased(MouseEvent e) {
-            if (!mouseIsDragging && selectedRect == null)
+            if (!mouseIsZoomSelecting(e) || selectedRect == null)
                 return;
 
@@ -359 +501 @@
 
             if (image == null) {
-                mouseIsDragging = false;
-                selectedRect = null;
                 return;
             }
 
-            if (mouseIsDragging) {
-                mouseIsDragging = false;
-
-            } else if (selectedRect != null) {
-                int oldWidth = selectedRect.width;
-                int oldHeight = selectedRect.height;
-
-                // Check that the zoom doesn't exceed 2:1
-                if (selectedRect.width < getSize().width / 2) {
-                    selectedRect.width = getSize().width / 2;
-                }
-                if (selectedRect.height < getSize().height / 2) {
-                    selectedRect.height = getSize().height / 2;
-                }
-
-                // Set the same ratio for the visible rectangle and the display area
-                int hFact = selectedRect.height * getSize().width;
-                int wFact = selectedRect.width * getSize().height;
-                if (hFact > wFact) {
-                    selectedRect.width = hFact / getSize().height;
-                } else {
-                    selectedRect.height = wFact / getSize().width;
-                }
-
-                // Keep the center of the selection
-                if (selectedRect.width != oldWidth) {
-                    selectedRect.x -= (selectedRect.width - oldWidth) / 2;
-                }
-                if (selectedRect.height != oldHeight) {
-                    selectedRect.y -= (selectedRect.height - oldHeight) / 2;
-                }
-
-                checkVisibleRectSize(image, selectedRect);
-                checkVisibleRectPos(image, selectedRect);
-
-                synchronized (ImageDisplay.this) {
-                    if (file == ImageDisplay.this.file) {
-                        ImageDisplay.this.visibleRect = selectedRect;
-                    }
-                }
-                selectedRect = null;
-                ImageDisplay.this.repaint();
-            }
+            int oldWidth = selectedRect.width;
+            int oldHeight = selectedRect.height;
+
+            // Check that the zoom doesn't exceed MAX_ZOOM:1
+            if (selectedRect.width < getSize().width / MAX_ZOOM.get()) {
+                selectedRect.width = (int) (getSize().width / MAX_ZOOM.get());
+            }
+            if (selectedRect.height < getSize().height / MAX_ZOOM.get()) {
+                selectedRect.height = (int) (getSize().height / MAX_ZOOM.get());
+            }
+
+            // Set the same ratio for the visible rectangle and the display area
+            int hFact = selectedRect.height * getSize().width;
+            int wFact = selectedRect.width * getSize().height;
+            if (hFact > wFact) {
+                selectedRect.width = hFact / getSize().height;
+            } else {
+                selectedRect.height = wFact / getSize().width;
+            }
+
+            // Keep the center of the selection
+            if (selectedRect.width != oldWidth) {
+                selectedRect.x -= (selectedRect.width - oldWidth) / 2;
+            }
+            if (selectedRect.height != oldHeight) {
+                selectedRect.y -= (selectedRect.height - oldHeight) / 2;
+            }
+
+            selectedRect.checkRectSize();
+            selectedRect.checkRectPos();
+
+            synchronized (ImageDisplay.this) {
+                if (file == ImageDisplay.this.file) {
+                    ImageDisplay.this.visibleRect.setBounds(selectedRect);
+                }
+            }
+            selectedRect = null;
+            ImageDisplay.this.repaint();
         }
 
@@ -422 +557 @@
         public void mouseMoved(MouseEvent e) {
             // Do nothing
-        }
-
-        private void checkPointInVisibleRect(Point p, Rectangle visibleRect) {
-            if (p.x < visibleRect.x) {
-                p.x = visibleRect.x;
-            }
-            if (p.x > visibleRect.x + visibleRect.width) {
-                p.x = visibleRect.x + visibleRect.width;
-            }
-            if (p.y < visibleRect.y) {
-                p.y = visibleRect.y;
-            }
-            if (p.y > visibleRect.y + visibleRect.height) {
-                p.y = visibleRect.y + visibleRect.height;
-            }
         }
     }
@@ -448 +568 @@
         addMouseWheelListener(mouseListener);
         addMouseMotionListener(mouseListener);
+        Config.getPref().addPreferenceChangeListener(this);
+        preferenceChanged(null);
     }
 
@@ -454 +576 @@
             this.file = file;
             image = null;
-            selectedRect = null;
             errorLoading = false;
         }
@@ -476 +597 @@
         Image image;
         File file;
-        Rectangle visibleRect;
+        VisRect visibleRect;
         boolean errorLoading;
 
@@ -511 +632 @@
                     (int) ((size.height - noImageSize.getHeight()) / 2));
         } else {
+            Rectangle r = new Rectangle(visibleRect);
             Rectangle target = calculateDrawImageRectangle(visibleRect, size);
-            // See https://community.oracle.com/docs/DOC-983611 - The Perils of Image.getScaledInstance()
-            // Pre-scale image when downscaling by more than two times to avoid aliasing from default algorithm
-            if (selectedRect == null && (target.width < visibleRect.width/2 || target.height < visibleRect.height/2)) {
-                BufferedImage buffImage = ImageProvider.toBufferedImage(image);
-                g.drawImage(ImageProvider.createScaledImage(buffImage, target.width, target.height, RenderingHints.VALUE_INTERPOLATION_BILINEAR),
-                        target.x, target.y, target.x + target.width, target.y + target.height,
-                        visibleRect.x, visibleRect.y, visibleRect.x + target.width, visibleRect.y + target.height,
-                        null);
+            double scale = target.width / (double) r.width; // pixel ratio is 1:1
+
+            if (selectedRect == null && BILIN_LOWER < scale && scale < BILIN_UPPER) {
+                BufferedImage bi = ImageProvider.toBufferedImage(image, r);
+                r.x = r.y = 0;
+
+                // See https://community.oracle.com/docs/DOC-983611 - The Perils of Image.getScaledInstance()
+                // Pre-scale image when downscaling by more than two times to avoid aliasing from default algorithm
+                image = ImageProvider.createScaledImage(bi, target.width, target.height,
+                            RenderingHints.VALUE_INTERPOLATION_BILINEAR);
+                r.width = target.width;
+                r.height = target.height;
             } else {
-                g.drawImage(image,
-                        target.x, target.y, target.x + target.width, target.y + target.height,
-                        visibleRect.x, visibleRect.y, visibleRect.x + visibleRect.width, visibleRect.y + visibleRect.height,
-                        null);
-            }
+                // if target and r cause drawImage to scale image region to a tmp buffer exceeding
+                // its bounds, it will silently fail; crop with r first in such cases
+                // (might be impl. dependent, exhibited by openjdk 1.8.0_151)
+                if (scale*(r.x+r.width) > Short.MAX_VALUE || scale*(r.y+r.height) > Short.MAX_VALUE) {
+                    image = ImageProvider.toBufferedImage(image, r);
+                    r.x = r.y = 0;
+                }
+            }
+
+            g.drawImage(image,
+                    target.x, target.y, target.x + target.width, target.y + target.height,
+                    r.x, r.y, r.x + r.width, r.y + r.height, null);
+
             if (selectedRect != null) {
                 Point topLeft = img2compCoord(visibleRect, selectedRect.x, selectedRect.y, size);
@@ -577 +711 @@
     }
 
-    static Point img2compCoord(Rectangle visibleRect, int xImg, int yImg, Dimension compSize) {
+    static Point img2compCoord(VisRect visibleRect, int xImg, int yImg, Dimension compSize) {
         Rectangle drawRect = calculateDrawImageRectangle(visibleRect, compSize);
         return new Point(drawRect.x + ((xImg - visibleRect.x) * drawRect.width) / visibleRect.width,
@@ -583 +717 @@
     }
 
-    static Point comp2imgCoord(Rectangle visibleRect, int xComp, int yComp, Dimension compSize) {
+    static Point comp2imgCoord(VisRect visibleRect, int xComp, int yComp, Dimension compSize) {
         Rectangle drawRect = calculateDrawImageRectangle(visibleRect, compSize);
-        return new Point(visibleRect.x + ((xComp - drawRect.x) * visibleRect.width) / drawRect.width,
-                visibleRect.y + ((yComp - drawRect.y) * visibleRect.height) / drawRect.height);
+        Point p = new Point(
+                        ((xComp - drawRect.x) * visibleRect.width),
+                        ((yComp - drawRect.y) * visibleRect.height));
+        p.x += (((p.x % drawRect.width) << 1) >= drawRect.width) ? drawRect.width : 0;
+        p.y += (((p.y % drawRect.height) << 1) >= drawRect.height) ? drawRect.height : 0;
+        p.x = visibleRect.x + p.x / drawRect.width;
+        p.y = visibleRect.y + p.y / drawRect.height;
+        return p;
     }
 
@@ -594 +734 @@
     }
 
-    static Rectangle calculateDrawImageRectangle(Rectangle visibleRect, Dimension compSize) {
+    static VisRect calculateDrawImageRectangle(VisRect visibleRect, Dimension compSize) {
         return calculateDrawImageRectangle(visibleRect, new Rectangle(0, 0, compSize.width, compSize.height));
     }
@@ -605 +745 @@
      * @return the part of compRect with the same width/height ratio as the image
      */
-    static Rectangle calculateDrawImageRectangle(Rectangle imgRect, Rectangle compRect) {
+    static VisRect calculateDrawImageRectangle(VisRect imgRect, Rectangle compRect) {
         int x = 0;
         int y = 0;
@@ -622 +762 @@
             }
         }
-        return new Rectangle(x + compRect.x, y + compRect.y, w, h);
+
+        // overscan to prevent empty edges when zooming in to zoom scales > 2:1
+        if (w > imgRect.width && h > imgRect.height && !imgRect.isFullView1D()) {
+            if (wFact != hFact) {
+                if (wFact > hFact) {
+                    w = compRect.width;
+                    x = 0;
+                    h = wFact / imgRect.width;
+                    y = (compRect.height - h) / 2;
+                } else {
+                    h = compRect.height;
+                    y = 0;
+                    w = hFact / imgRect.height;
+                    x = (compRect.width - w) / 2;
+                }
+            }
+        }
+
+        return new VisRect(x + compRect.x, y + compRect.y, w, h, imgRect);
     }
 
@@ -628 +786 @@
         File file;
         Image image;
-        Rectangle visibleRect;
+        VisRect visibleRect;
 
         synchronized (this) {
@@ -641 +799 @@
         if (visibleRect.width != image.getWidth(null) || visibleRect.height != image.getHeight(null)) {
             // The display is not at best fit. => Zoom to best fit
-            visibleRect = new Rectangle(0, 0, image.getWidth(null), image.getHeight(null));
-
+            visibleRect.reset();
         } else {
             // The display is at best fit => zoom to 1:1
             Point center = getCenterImgCoord(visibleRect);
-            visibleRect = new Rectangle(center.x - getWidth() / 2, center.y - getHeight() / 2,
+            visibleRect.setBounds(center.x - getWidth() / 2, center.y - getHeight() / 2,
                     getWidth(), getHeight());
-            checkVisibleRectPos(image, visibleRect);
+            visibleRect.checkRectSize();
+            visibleRect.checkRectPos();
         }
 
@@ -658 +816 @@
         repaint();
     }
-
-    static void checkVisibleRectPos(Image image, Rectangle visibleRect) {
-        if (visibleRect.x < 0) {
-            visibleRect.x = 0;
-        }
-        if (visibleRect.y < 0) {
-            visibleRect.y = 0;
-        }
-        if (visibleRect.x + visibleRect.width > image.getWidth(null)) {
-            visibleRect.x = image.getWidth(null) - visibleRect.width;
-        }
-        if (visibleRect.y + visibleRect.height > image.getHeight(null)) {
-            visibleRect.y = image.getHeight(null) - visibleRect.height;
-        }
-    }
-
-    static void checkVisibleRectSize(Image image, Rectangle visibleRect) {
-        if (visibleRect.width > image.getWidth(null)) {
-            visibleRect.width = image.getWidth(null);
-        }
-        if (visibleRect.height > image.getHeight(null)) {
-            visibleRect.height = image.getHeight(null);
-        }
-    }
 }

trunk/src/org/openstreetmap/josm/gui/layer/geoimage/ThumbsLoader.java

@@ -21 +21 @@
 import org.openstreetmap.josm.data.cache.JCSCacheManager;
 import org.openstreetmap.josm.gui.MainApplication;
+import org.openstreetmap.josm.gui.layer.geoimage.ImageDisplay.VisRect;
 import org.openstreetmap.josm.spi.preferences.Config;
 import org.openstreetmap.josm.tools.ExifReader;
@@ -141 +142 @@
 
         Rectangle targetSize = ImageDisplay.calculateDrawImageRectangle(
-                new Rectangle(0, 0, ww, hh),
+                new VisRect(0, 0, ww, hh),
                 new Rectangle(0, 0, maxSize, maxSize));
         BufferedImage scaledBI = new BufferedImage(targetSize.width, targetSize.height, BufferedImage.TYPE_INT_RGB);

trunk/src/org/openstreetmap/josm/tools/ImageProvider.java

@@ -12 +12 @@
 import java.awt.Image;
 import java.awt.Point;
+import java.awt.Rectangle;
 import java.awt.RenderingHints;
 import java.awt.Toolkit;
@@ -1421 +1422 @@
             if (w > targetWidth) {
                 w /= 2;
-                if (w < targetWidth) {
-                    w = targetWidth;
-                }
+            }
+            if (w < targetWidth) {
+                w = targetWidth;
             }
             if (h > targetHeight) {
                 h /= 2;
-                if (h < targetHeight) {
-                    h = targetHeight;
-                }
+            }
+            if (h < targetHeight) {
+                h = targetHeight;
             }
             BufferedImage tmp = new BufferedImage(w, h, type);
@@ -1976 +1977 @@
         }
     }
+
+    /**
+     * Converts an {@link Rectangle} area of {@link Image} to a {@link BufferedImage} instance.
+     * @param image image to convert
+     * @param crop_area rectangle to crop image with
+     * @return a {@code BufferedImage} instance for the cropped area of {@code Image}.
+     * @since 13127
+     */
+    public static BufferedImage toBufferedImage(Image image, Rectangle crop_area) {
+        BufferedImage buffImage = null;
+
+        Rectangle r = new Rectangle(image.getWidth(null), image.getHeight(null));
+        if (r.intersection(crop_area).equals(crop_area)) {
+            buffImage = new BufferedImage(crop_area.width, crop_area.height, BufferedImage.TYPE_INT_ARGB);
+            Graphics2D g2 = buffImage.createGraphics();
+            g2.drawImage(image,
+                0, 0, crop_area.width, crop_area.height,
+                crop_area.x, crop_area.y,
+                crop_area.x + crop_area.width, crop_area.y + crop_area.height,
+                null);
+            g2.dispose();
+        }
+        return buffImage;
+    }
 }

trunk/test/unit/org/openstreetmap/josm/gui/layer/geoimage/ImageDisplayTest.java

@@ -9 +9 @@
 import org.junit.Rule;
 import org.junit.Test;
+import org.openstreetmap.josm.gui.layer.geoimage.ImageDisplay.VisRect;
 import org.openstreetmap.josm.testutils.JOSMTestRules;
 
@@ -30 +31 @@
     public void testCalculateDrawImageRectangle() {
         assertEquals(new Rectangle(),
-                ImageDisplay.calculateDrawImageRectangle(new Rectangle(), new Dimension()));
+                ImageDisplay.calculateDrawImageRectangle(new VisRect(), new Dimension()));
         assertEquals(new Rectangle(0, 0, 10, 5),
-                ImageDisplay.calculateDrawImageRectangle(new Rectangle(0, 0, 10, 5), new Dimension(10, 5)));
+                ImageDisplay.calculateDrawImageRectangle(new VisRect(0, 0, 10, 5), new Dimension(10, 5)));
         assertEquals(new Rectangle(0, 0, 10, 5),
-                ImageDisplay.calculateDrawImageRectangle(new Rectangle(0, 0, 20, 10), new Dimension(10, 5)));
+                ImageDisplay.calculateDrawImageRectangle(new VisRect(0, 0, 20, 10), new Dimension(10, 5)));
         assertEquals(new Rectangle(0, 0, 20, 10),
-                ImageDisplay.calculateDrawImageRectangle(new Rectangle(0, 0, 10, 5), new Dimension(20, 10)));
+                ImageDisplay.calculateDrawImageRectangle(new VisRect(0, 0, 10, 5), new Dimension(20, 10)));
         assertEquals(new Rectangle(5, 0, 24, 12),
-                ImageDisplay.calculateDrawImageRectangle(new Rectangle(0, 0, 10, 5), new Dimension(35, 12)));
+                ImageDisplay.calculateDrawImageRectangle(new VisRect(0, 0, 10, 5), new Dimension(35, 12)));
         assertEquals(new Rectangle(0, 1, 8, 4),
-                ImageDisplay.calculateDrawImageRectangle(new Rectangle(0, 0, 10, 5), new Dimension(8, 6)));
+                ImageDisplay.calculateDrawImageRectangle(new VisRect(0, 0, 10, 5), new Dimension(8, 6)));
     }
 }