Changeset 18246 in josm

Timestamp:

2021-10-04T16:05:23+02:00 (3 years ago)

Author:

Don-vip

Message:

see #16472 - add initial working 360 viewer, minimal tests, many tests disabled due to failures, but is usable (patch by taylor.smock)

Location:

trunk

Files:

• src/org/openstreetmap/josm/data/ImageData.java (modified) (5 diffs)
• src/org/openstreetmap/josm/data/gpx/GpxImageEntry.java (modified) (8 diffs)
• src/org/openstreetmap/josm/data/imagery/street_level (added)
• src/org/openstreetmap/josm/data/imagery/street_level/IImageEntry.java (added)
• src/org/openstreetmap/josm/data/imagery/street_level/Projections.java (added)
• src/org/openstreetmap/josm/data/osm/FilterWorker.java (modified) (1 diff)
• src/org/openstreetmap/josm/data/osm/QuadBuckets.java (modified) (1 diff)
• src/org/openstreetmap/josm/data/sources/SourceInfo.java (modified) (1 diff)
• src/org/openstreetmap/josm/gui/layer/geoimage/GeoImageLayer.java (modified) (1 diff)
• src/org/openstreetmap/josm/gui/layer/geoimage/ImageDisplay.java (modified) (25 diffs)
• src/org/openstreetmap/josm/gui/layer/geoimage/ImageEntry.java (modified) (5 diffs)
• src/org/openstreetmap/josm/gui/layer/geoimage/ImageViewerDialog.java (modified) (18 diffs)
• src/org/openstreetmap/josm/gui/layer/geoimage/viewers (added)
• src/org/openstreetmap/josm/gui/layer/geoimage/viewers/projections (added)
• src/org/openstreetmap/josm/gui/layer/geoimage/viewers/projections/Equirectangular.java (added)
• src/org/openstreetmap/josm/gui/layer/geoimage/viewers/projections/IImageViewer.java (added)
• src/org/openstreetmap/josm/gui/layer/geoimage/viewers/projections/ImageProjectionRegistry.java (added)
• src/org/openstreetmap/josm/gui/layer/geoimage/viewers/projections/Perspective.java (added)
• src/org/openstreetmap/josm/gui/util/imagery (added)
• src/org/openstreetmap/josm/gui/util/imagery/CameraPlane.java (added)
• src/org/openstreetmap/josm/gui/util/imagery/UVMapping.java (added)
• src/org/openstreetmap/josm/gui/util/imagery/Vector3D.java (added)
• test/unit/org/openstreetmap/josm/gui/util/imagery (added)
• test/unit/org/openstreetmap/josm/gui/util/imagery/CameraPlaneTest.java (added)
• test/unit/org/openstreetmap/josm/gui/util/imagery/UVMappingTest.java (added)
• test/unit/org/openstreetmap/josm/gui/util/imagery/Vector3DTest.java (added)

trunk/src/org/openstreetmap/josm/data/ImageData.java

@@ -133 +133 @@
 
     /**
+     * Get the first image on the layer
+     * @return The first image
+     * @since 18246
+     */
+    public ImageEntry getFirstImage() {
+        if (!this.data.isEmpty()) {
+            return this.data.get(0);
+        }
+        return null;
+    }
+
+    /**
      * Select the first image of the sequence
-     */
+     * @deprecated Use {@link #getFirstImage()} in conjunction with {@link #setSelectedImage}
+     */
+    @Deprecated
     public void selectFirstImage() {
         if (!data.isEmpty()) {
@@ -142 +156 @@
 
     /**
+     * Get the last image in the layer
+     * @return The last image
+     * @since 18246
+     */
+    public ImageEntry getLastImage() {
+        if (!this.data.isEmpty()) {
+            return this.data.get(this.data.size() - 1);
+        }
+        return null;
+    }
+
+    /**
      * Select the last image of the sequence
-     */
+     * @deprecated Use {@link #getLastImage()} with {@link #setSelectedImage}
+     */
+    @Deprecated
     public void selectLastImage() {
         setSelectedImageIndex(data.size() - 1);
@@ -167 +195 @@
 
     /**
+     * Get the image next to the current image
+     * @return The next image
+     * @since 18246
+     */
+    public ImageEntry getNextImage() {
+        if (this.hasNextImage()) {
+            return this.data.get(this.selectedImagesIndex.get(0) + 1);
+        }
+        return null;
+    }
+
+    /**
      * Select the next image of the sequence
-     */
+     * @deprecated Use {@link #getNextImage()} in conjunction with {@link #setSelectedImage}
+     */
+    @Deprecated
     public void selectNextImage() {
         if (hasNextImage()) {
@@ -176 +218 @@
 
     /**
+     * Get the image previous to the current image
+     * @return The previous image
+     * @since 18246
+     */
+    public ImageEntry getPreviousImage() {
+        if (this.hasPreviousImage()) {
+            return this.data.get(Integer.max(0, selectedImagesIndex.get(0) - 1));
+        }
+        return null;
+    }
+
+    /**
      *  Check if there is a previous image in the sequence
      * @return {@code true} is there is a previous image, {@code false} otherwise
@@ -185 +239 @@
     /**
      * Select the previous image of the sequence
-     */
+     * @deprecated Use {@link #getPreviousImage()} with {@link #setSelectedImage}
+     */
+    @Deprecated
     public void selectPreviousImage() {
         if (data.isEmpty()) {

trunk/src/org/openstreetmap/josm/data/gpx/GpxImageEntry.java

@@ -4 +4 @@
 import static org.openstreetmap.josm.tools.I18n.tr;
 
+import java.awt.Dimension;
+import java.awt.image.BufferedImage;
 import java.io.File;
 import java.io.IOException;
@@ -10 +12 @@
 import java.util.List;
 import java.util.Locale;
+import java.util.Map;
 import java.util.Objects;
 import java.util.function.Consumer;
+import java.util.stream.Stream;
+
+import javax.imageio.IIOParam;
 
 import org.openstreetmap.josm.data.IQuadBucketType;
 import org.openstreetmap.josm.data.coor.CachedLatLon;
 import org.openstreetmap.josm.data.coor.LatLon;
+import org.openstreetmap.josm.data.imagery.street_level.Projections;
 import org.openstreetmap.josm.data.osm.BBox;
 import org.openstreetmap.josm.tools.ExifReader;
@@ -34 +41 @@
 import com.drew.metadata.iptc.IptcDirectory;
 import com.drew.metadata.jpeg.JpegDirectory;
+import com.drew.metadata.xmp.XmpDirectory;
 
 /**
@@ -45 +53 @@
     private Double exifImgDir;
     private Instant exifTime;
+    private Projections cameraProjection = Projections.UNKNOWN;
     /**
      * Flag isNewGpsData indicates that the GPS data of the image is new or has changed.
@@ -478 +487 @@
             elevation, exifCoor, exifGpsTime, exifImgDir, exifOrientation, exifTime,
             iptcCaption, iptcHeadline, iptcKeywords, iptcObjectName,
-            file, gpsTime, pos, speed, tmp);
+            file, gpsTime, pos, speed, tmp, cameraProjection);
     }
 
@@ -505 +514 @@
             && Objects.equals(pos, other.pos)
             && Objects.equals(speed, other.speed)
-            && Objects.equals(tmp, other.tmp);
+            && Objects.equals(tmp, other.tmp)
+            && cameraProjection == other.cameraProjection;
     }
 
@@ -754 +764 @@
             ifNotNull(ExifReader.readObjectName(dirIptc), this::setIptcObjectName);
         }
+
+        for (XmpDirectory xmpDirectory : metadata.getDirectoriesOfType(XmpDirectory.class)) {
+            Map<String, String> properties = xmpDirectory.getXmpProperties();
+            final String projectionType = "GPano:ProjectionType";
+            if (properties.containsKey(projectionType)) {
+                Stream.of(Projections.values()).filter(p -> p.name().equalsIgnoreCase(properties.get(projectionType)))
+                        .findFirst().ifPresent(projection -> this.cameraProjection = projection);
+                break;
+            }
+        }
+    }
+
+    /**
+     * Reads the image represented by this entry in the given target dimension.
+     * @param target the desired dimension used for {@linkplain IIOParam#setSourceSubsampling subsampling} or {@code null}
+     * @return the read image, or {@code null}
+     * @throws IOException if any I/O error occurs
+     * @since 18246
+     */
+    public BufferedImage read(Dimension target) throws IOException {
+        throw new UnsupportedOperationException("read not implemented for " + this.getClass().getSimpleName());
     }
 
@@ -766 +797 @@
             setter.accept(value);
         }
+    }
+
+    /**
+     * Get the projection type for this entry
+     * @return The projection type
+     * @since 18246
+     */
+    public Projections getProjectionType() {
+        return this.cameraProjection;
     }
 

trunk/src/org/openstreetmap/josm/data/osm/FilterWorker.java

@@ -30 +30 @@
      * @return true, if the filter state (normal / disabled / hidden) of any primitive has changed in the process
      * @throws SearchParseError if the search expression in a filter cannot be parsed
-     * @since 12383, xxx (generics)
+     * @since 12383, 17862 (generics)
      */
     public static <T extends IPrimitive & IFilterablePrimitive> boolean executeFilters(Collection<T> all, Filter... filters)

trunk/src/org/openstreetmap/josm/data/osm/QuadBuckets.java

@@ -23 +23 @@
  * This class is (no longer) thread safe.
  * @param <T> type of object extending {@link IQuadBucketType}.
- * @since 2165 ({@link IPrimitive} only), xxx for {@link IQuadBucketType}
+ * @since 2165 ({@link IPrimitive} only), 17459 for {@link IQuadBucketType}
  */
 public class QuadBuckets<T extends IQuadBucketType> implements Collection<T> {

trunk/src/org/openstreetmap/josm/data/sources/SourceInfo.java

@@ -490 +490 @@
      * @param clazz The class of the type of id
      * @return sorted list of activated source IDs
-     * @since 13536, xxx (extracted)
+     * @since 13536, 16545 (extracted)
      */
     public static <W extends SourceInfo<?, ?, ?, ?>> Collection<String> getActiveIds(Class<W> clazz) {

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

@@ -868 +868 @@
     @Override
     public void jumpToNextMarker() {
-        data.selectNextImage();
+        data.setSelectedImage(data.getNextImage());
     }
 
     @Override
     public void jumpToPreviousMarker() {
-        data.selectPreviousImage();
+        data.setSelectedImage(data.getPreviousImage());
     }
 

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

@@ -13 +13 @@
 import java.awt.Rectangle;
 import java.awt.RenderingHints;
+import java.awt.event.ComponentEvent;
+import java.awt.event.MouseAdapter;
 import java.awt.event.MouseEvent;
-import java.awt.event.MouseListener;
-import java.awt.event.MouseMotionListener;
 import java.awt.event.MouseWheelEvent;
-import java.awt.event.MouseWheelListener;
 import java.awt.geom.Rectangle2D;
 import java.awt.image.BufferedImage;
@@ -27 +26 @@
 import javax.swing.SwingUtilities;
 
+import org.openstreetmap.josm.data.imagery.street_level.IImageEntry;
+import org.openstreetmap.josm.data.imagery.street_level.Projections;
 import org.openstreetmap.josm.data.preferences.BooleanProperty;
 import org.openstreetmap.josm.data.preferences.DoubleProperty;
 import org.openstreetmap.josm.data.preferences.IntegerProperty;
 import org.openstreetmap.josm.gui.MainApplication;
+import org.openstreetmap.josm.gui.layer.geoimage.viewers.projections.IImageViewer;
+import org.openstreetmap.josm.gui.layer.geoimage.viewers.projections.ImageProjectionRegistry;
 import org.openstreetmap.josm.gui.layer.imagery.ImageryFilterSettings;
 import org.openstreetmap.josm.gui.layer.imagery.ImageryFilterSettings.FilterChangeListener;
@@ -39 +42 @@
 import org.openstreetmap.josm.tools.Destroyable;
 import org.openstreetmap.josm.tools.ImageProcessor;
+import org.openstreetmap.josm.tools.JosmRuntimeException;
 import org.openstreetmap.josm.tools.Logging;
 import org.openstreetmap.josm.tools.Utils;
@@ -50 +54 @@
 public class ImageDisplay extends JComponent implements Destroyable, PreferenceChangedListener, FilterChangeListener {
 
+    /** The current image viewer */
+    private IImageViewer iImageViewer;
+
     /** The file that is currently displayed */
-    private ImageEntry entry;
+    private IImageEntry<?> entry;
 
     /** The previous file that is currently displayed. Cleared on paint. Only used to help improve UI error information. */
-    private ImageEntry oldEntry;
+    private IImageEntry<?> oldEntry;
 
     /** The image currently displayed */
@@ -262 +269 @@
     protected class LoadImageRunnable implements Runnable {
 
-        private final ImageEntry entry;
-
-        LoadImageRunnable(ImageEntry entry) {
+        private final IImageEntry<?> entry;
+
+        LoadImageRunnable(IImageEntry<?> entry) {
             this.entry = entry;
         }
@@ -296 +303 @@
                     // This will clear the loading info box
                     ImageDisplay.this.oldEntry = ImageDisplay.this.entry;
-                    visibleRect = new VisRect(0, 0, width, height);
+                    visibleRect = getIImageViewer(entry).getDefaultVisibleRectangle(ImageDisplay.this, image);
 
                     selectedRect = null;
@@ -308 +315 @@
     }
 
-    private class ImgDisplayMouseListener implements MouseListener, MouseWheelListener, MouseMotionListener {
+    private class ImgDisplayMouseListener extends MouseAdapter {
 
         private MouseEvent lastMouseEvent;
@@ -331 +338 @@
 
         private void mouseWheelMovedImpl(int x, int y, int rotation, boolean refreshMousePointInImg) {
-            ImageEntry entry;
-            Image image;
-            VisRect visibleRect;
+            IImageEntry<?> currentEntry;
+            IImageViewer imageViewer;
+            Image currentImage;
+            VisRect currentVisibleRect;
 
             synchronized (ImageDisplay.this) {
-                entry = ImageDisplay.this.entry;
-                image = ImageDisplay.this.image;
-                visibleRect = ImageDisplay.this.visibleRect;
+                currentEntry = ImageDisplay.this.entry;
+                currentImage = ImageDisplay.this.image;
+                currentVisibleRect = ImageDisplay.this.visibleRect;
+                imageViewer = ImageDisplay.this.iImageViewer;
             }
 
             selectedRect = null;
 
-            if (image == null)
+            if (currentImage == null)
                 return;
 
             // Calculate the mouse cursor position in image coordinates to center the zoom.
             if (refreshMousePointInImg)
-                mousePointInImg = comp2imgCoord(visibleRect, x, y, getSize());
+                mousePointInImg = comp2imgCoord(currentVisibleRect, 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());
+                currentVisibleRect.width = (int) (currentVisibleRect.width * ZOOM_STEP.get());
+                currentVisibleRect.height = (int) (currentVisibleRect.height * ZOOM_STEP.get());
             } else {
-                visibleRect.width = (int) (visibleRect.width / ZOOM_STEP.get());
-                visibleRect.height = (int) (visibleRect.height / ZOOM_STEP.get());
+                currentVisibleRect.width = (int) (currentVisibleRect.width / ZOOM_STEP.get());
+                currentVisibleRect.height = (int) (currentVisibleRect.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());
-            }
-
-            // Set the same ratio for the visible rectangle and the display area
-            int hFact = visibleRect.height * getSize().width;
-            int wFact = visibleRect.width * getSize().height;
-            if (hFact > wFact) {
-                visibleRect.width = hFact / getSize().height;
+            ensureMaxZoom(currentVisibleRect);
+
+            // The size of the visible rectangle is limited by the image size or the viewer implementation.
+            if (imageViewer != null) {
+                imageViewer.checkAndModifyVisibleRectSize(currentImage, currentVisibleRect);
             } else {
-                visibleRect.height = wFact / getSize().width;
-            }
-
-            // The size of the visible rectangle is limited by the image size.
-            visibleRect.checkRectSize();
+                currentVisibleRect.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 - x) * visibleRect.width) / drawRect.width;
-            visibleRect.y = mousePointInImg.y + ((drawRect.y - y) * visibleRect.height) / drawRect.height;
+            Rectangle drawRect = calculateDrawImageRectangle(currentVisibleRect, getSize());
+            currentVisibleRect.x = mousePointInImg.x + ((drawRect.x - x) * currentVisibleRect.width) / drawRect.width;
+            currentVisibleRect.y = mousePointInImg.y + ((drawRect.y - y) * currentVisibleRect.height) / drawRect.height;
 
             // The position is also limited by the image size
-            visibleRect.checkRectPos();
+            currentVisibleRect.checkRectPos();
 
             synchronized (ImageDisplay.this) {
-                if (ImageDisplay.this.entry == entry) {
-                    ImageDisplay.this.visibleRect = visibleRect;
+                if (ImageDisplay.this.entry == currentEntry) {
+                    ImageDisplay.this.visibleRect = currentVisibleRect;
                 }
             }
@@ -417 +416 @@
         public void mouseClicked(MouseEvent e) {
             // Move the center to the clicked point.
-            ImageEntry entry;
-            Image image;
-            VisRect visibleRect;
+            IImageEntry<?> currentEntry;
+            Image currentImage;
+            VisRect currentVisibleRect;
 
             synchronized (ImageDisplay.this) {
-                entry = ImageDisplay.this.entry;
-                image = ImageDisplay.this.image;
-                visibleRect = ImageDisplay.this.visibleRect;
-            }
-
-            if (image == null)
+                currentEntry = ImageDisplay.this.entry;
+                currentImage = ImageDisplay.this.image;
+                currentVisibleRect = ImageDisplay.this.visibleRect;
+            }
+
+            if (currentImage == null)
                 return;
 
@@ -434 +433 @@
                 lastMouseEvent = null;
 
-                if (mouseIsZoomSelecting(e) && !isAtMaxZoom(visibleRect)) {
+                if (mouseIsZoomSelecting(e) && !isAtMaxZoom(currentVisibleRect)) {
                     // zoom in if clicked with the zoom button
                     mouseWheelMovedImpl(e.getX(), e.getY(), -1, true);
@@ -447 +446 @@
 
             // Calculate the translation to set the clicked point the center of the view.
-            Point click = comp2imgCoord(visibleRect, e.getX(), e.getY(), getSize());
-            Point center = getCenterImgCoord(visibleRect);
-
-            visibleRect.x += click.x - center.x;
-            visibleRect.y += click.y - center.y;
-
-            visibleRect.checkRectPos();
+            Point click = comp2imgCoord(currentVisibleRect, e.getX(), e.getY(), getSize());
+            Point center = getCenterImgCoord(currentVisibleRect);
+
+            currentVisibleRect.x += click.x - center.x;
+            currentVisibleRect.y += click.y - center.y;
+
+            currentVisibleRect.checkRectPos();
 
             synchronized (ImageDisplay.this) {
-                if (ImageDisplay.this.entry == entry) {
-                    ImageDisplay.this.visibleRect = visibleRect;
+                if (ImageDisplay.this.entry == currentEntry) {
+                    ImageDisplay.this.visibleRect = currentVisibleRect;
                 }
             }
@@ -467 +466 @@
         @Override
         public void mousePressed(MouseEvent e) {
-            Image image;
-            VisRect visibleRect;
+            Image currentImage;
+            VisRect currentVisibleRect;
 
             synchronized (ImageDisplay.this) {
-                image = ImageDisplay.this.image;
-                visibleRect = ImageDisplay.this.visibleRect;
-            }
-
-            if (image == null)
+                currentImage = ImageDisplay.this.image;
+                currentVisibleRect = ImageDisplay.this.visibleRect;
+            }
+
+            if (currentImage == null)
                 return;
 
@@ -481 +480 @@
 
             if (mouseIsDragging(e) || mouseIsZoomSelecting(e))
-                mousePointInImg = comp2imgCoord(visibleRect, e.getX(), e.getY(), getSize());
+                mousePointInImg = comp2imgCoord(currentVisibleRect, e.getX(), e.getY(), getSize());
         }
 
@@ -489 +488 @@
                 return;
 
-            ImageEntry entry;
-            Image image;
-            VisRect visibleRect;
+            IImageEntry<?> imageEntry;
+            Image currentImage;
+            VisRect currentVisibleRect;
 
             synchronized (ImageDisplay.this) {
-                entry = ImageDisplay.this.entry;
-                image = ImageDisplay.this.image;
-                visibleRect = ImageDisplay.this.visibleRect;
-            }
-
-            if (image == null)
+                imageEntry = ImageDisplay.this.entry;
+                currentImage = ImageDisplay.this.image;
+                currentVisibleRect = ImageDisplay.this.visibleRect;
+            }
+
+            if (currentImage == null)
                 return;
 
             if (mouseIsDragging(e) && mousePointInImg != null) {
-                Point p = comp2imgCoord(visibleRect, e.getX(), e.getY(), getSize());
-                visibleRect.isDragUpdate = true;
-                visibleRect.x += mousePointInImg.x - p.x;
-                visibleRect.y += mousePointInImg.y - p.y;
-                visibleRect.checkRectPos();
+                Point p = comp2imgCoord(currentVisibleRect, e.getX(), e.getY(), getSize());
+                getIImageViewer(entry).mouseDragged(this.mousePointInImg, p, currentVisibleRect);
+                currentVisibleRect.checkRectPos();
                 synchronized (ImageDisplay.this) {
-                    if (ImageDisplay.this.entry == entry) {
-                        ImageDisplay.this.visibleRect = visibleRect;
+                    if (ImageDisplay.this.entry == imageEntry) {
+                        ImageDisplay.this.visibleRect = currentVisibleRect;
                     }
                 }
+                // We have to update the mousePointInImg for 360 image panning, as otherwise the panning
+                // never stops.
+                // This does not work well with the perspective viewer at this time (2021-08-26).
+                if (entry != null && Projections.EQUIRECTANGULAR == entry.getProjectionType()) {
+                    this.mousePointInImg = p;
+                }
                 ImageDisplay.this.repaint();
             }
 
             if (mouseIsZoomSelecting(e) && mousePointInImg != null) {
-                Point p = comp2imgCoord(visibleRect, e.getX(), e.getY(), getSize());
-                visibleRect.checkPointInside(p);
-                VisRect selectedRect = new VisRect(
-                        p.x < mousePointInImg.x ? p.x : mousePointInImg.x,
-                        p.y < mousePointInImg.y ? p.y : mousePointInImg.y,
+                Point p = comp2imgCoord(currentVisibleRect, e.getX(), e.getY(), getSize());
+                currentVisibleRect.checkPointInside(p);
+                VisRect selectedRectTemp = new VisRect(
+                        Math.min(p.x, mousePointInImg.x),
+                        Math.min(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,
-                        visibleRect);
-                selectedRect.checkRectSize();
-                selectedRect.checkRectPos();
-                ImageDisplay.this.selectedRect = selectedRect;
+                        currentVisibleRect);
+                selectedRectTemp.checkRectSize();
+                selectedRectTemp.checkRectPos();
+                ImageDisplay.this.selectedRect = selectedRectTemp;
                 ImageDisplay.this.repaint();
             }
-
         }
 
         @Override
         public void mouseReleased(MouseEvent e) {
-            ImageEntry entry;
-            Image image;
-            VisRect visibleRect;
+            IImageEntry<?> currentEntry;
+            Image currentImage;
+            VisRect currentVisibleRect;
 
             synchronized (ImageDisplay.this) {
-                entry = ImageDisplay.this.entry;
-                image = ImageDisplay.this.image;
-                visibleRect = ImageDisplay.this.visibleRect;
-            }
-
-            if (image == null)
+                currentEntry = ImageDisplay.this.entry;
+                currentImage = ImageDisplay.this.image;
+                currentVisibleRect = ImageDisplay.this.visibleRect;
+            }
+
+            if (currentImage == null)
                 return;
 
             if (mouseIsDragging(e)) {
-                visibleRect.isDragUpdate = false;
+                currentVisibleRect.isDragUpdate = false;
             }
 
@@ -557 +559 @@
 
                 // 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;
-                }
+                ensureMaxZoom(selectedRect);
 
                 // Keep the center of the selection
@@ -586 +574 @@
 
             synchronized (ImageDisplay.this) {
-                if (entry == ImageDisplay.this.entry) {
+                if (currentEntry == ImageDisplay.this.entry) {
                     if (selectedRect == null) {
-                        ImageDisplay.this.visibleRect = visibleRect;
+                        ImageDisplay.this.visibleRect = currentVisibleRect;
                     } else {
                         ImageDisplay.this.visibleRect.setBounds(selectedRect);
@@ -597 +585 @@
             ImageDisplay.this.repaint();
         }
-
-        @Override
-        public void mouseEntered(MouseEvent e) {
-            // Do nothing
-        }
-
-        @Override
-        public void mouseExited(MouseEvent e) {
-            // Do nothing
-        }
-
-        @Override
-        public void mouseMoved(MouseEvent e) {
-            // Do nothing
-        }
     }
 
@@ -618 +591 @@
      */
     public ImageDisplay() {
-        this(image -> image);
+        this(imageObject -> imageObject);
     }
 
@@ -653 +626 @@
      * @param entry new source image
      * @return a {@link Future} representing pending completion of the image loading task
-     * @since 18150
-     */
-    public Future<?> setImage(ImageEntry entry) {
+     * @since 18246 (signature)
+     */
+    public Future<?> setImage(IImageEntry<?> entry) {
         LoadImageRunnable runnable = setImage0(entry);
         return runnable != null ? MainApplication.worker.submit(runnable) : null;
     }
 
-    protected LoadImageRunnable setImage0(ImageEntry entry) {
+    protected LoadImageRunnable setImage0(IImageEntry<?> entry) {
         synchronized (this) {
             this.oldEntry = this.entry;
@@ -708 +681 @@
     private void updateProcessedImage() {
         processedImage = image == null ? null : imageProcessor.process(image);
-        GuiHelper.runInEDT(() -> repaint());
+        GuiHelper.runInEDT(this::repaint);
     }
 
@@ -715 +688 @@
         super.paintComponent(g);
 
-        ImageEntry entry;
-        ImageEntry oldEntry;
-        BufferedImage image;
-        VisRect visibleRect;
-        boolean errorLoading;
+        IImageEntry<?> currentEntry;
+        IImageEntry<?> currentOldEntry;
+        IImageViewer currentImageViewer;
+        BufferedImage currentImage;
+        VisRect currentVisibleRect;
+        boolean currentErrorLoading;
 
         synchronized (this) {
-            image = this.processedImage;
-            entry = this.entry;
-            oldEntry = this.oldEntry;
-            visibleRect = this.visibleRect;
-            errorLoading = this.errorLoading;
+            currentImage = this.processedImage;
+            currentEntry = this.entry;
+            currentOldEntry = this.oldEntry;
+            currentVisibleRect = this.visibleRect;
+            currentErrorLoading = this.errorLoading;
         }
 
@@ -735 +709 @@
         Dimension size = getSize();
         // Draw the image first, then draw error information
-        if (image != null && (entry != null || oldEntry != null)) {
-            Rectangle r = new Rectangle(visibleRect);
-            Rectangle target = calculateDrawImageRectangle(visibleRect, size);
-
-            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);
-                Point bottomRight = img2compCoord(visibleRect,
-                        selectedRect.x + selectedRect.width,
-                        selectedRect.y + selectedRect.height, size);
-                g.setColor(new Color(128, 128, 128, 180));
-                g.fillRect(target.x, target.y, target.width, topLeft.y - target.y);
-                g.fillRect(target.x, target.y, topLeft.x - target.x, target.height);
-                g.fillRect(bottomRight.x, target.y, target.x + target.width - bottomRight.x, target.height);
-                g.fillRect(target.x, bottomRight.y, target.width, target.y + target.height - bottomRight.y);
-                g.setColor(Color.black);
-                g.drawRect(topLeft.x, topLeft.y, bottomRight.x - topLeft.x, bottomRight.y - topLeft.y);
-            }
-            if (errorLoading && entry != null) {
-                String loadingStr = tr("Error on file {0}", entry.getDisplayName());
+        if (currentImage != null && (currentEntry != null || currentOldEntry != null)) {
+            currentImageViewer = this.getIImageViewer(currentEntry);
+            Rectangle r = new Rectangle(currentVisibleRect);
+            Rectangle target = calculateDrawImageRectangle(currentVisibleRect, size);
+
+            currentImageViewer.paintImage(g, currentImage, target, r);
+            paintSelectedRect(g, target, currentVisibleRect, size);
+            if (currentErrorLoading && currentEntry != null) {
+                String loadingStr = tr("Error on file {0}", currentEntry.getDisplayName());
                 Rectangle2D noImageSize = g.getFontMetrics(g.getFont()).getStringBounds(loadingStr, g);
-                g.drawString(loadingStr,
-                        (int) ((size.width - noImageSize.getWidth()) / 2),
+                g.drawString(loadingStr, (int) ((size.width - noImageSize.getWidth()) / 2),
                         (int) ((size.height - noImageSize.getHeight()) / 2));
             }
-            if (osdText != null) {
-                FontMetrics metrics = g.getFontMetrics(g.getFont());
-                int ascent = metrics.getAscent();
-                Color bkground = new Color(255, 255, 255, 128);
-                int lastPos = 0;
-                int pos = osdText.indexOf('\n');
-                int x = 3;
-                int y = 3;
-                String line;
-                while (pos > 0) {
-                    line = osdText.substring(lastPos, pos);
-                    Rectangle2D lineSize = metrics.getStringBounds(line, g);
-                    g.setColor(bkground);
-                    g.fillRect(x, y, (int) lineSize.getWidth(), (int) lineSize.getHeight());
-                    g.setColor(Color.black);
-                    g.drawString(line, x, y + ascent);
-                    y += (int) lineSize.getHeight();
-                    lastPos = pos + 1;
-                    pos = osdText.indexOf('\n', lastPos);
-                }
-
-                line = osdText.substring(lastPos);
-                Rectangle2D lineSize = g.getFontMetrics(g.getFont()).getStringBounds(line, g);
-                g.setColor(bkground);
-                g.fillRect(x, y, (int) lineSize.getWidth(), (int) lineSize.getHeight());
-                g.setColor(Color.black);
-                g.drawString(line, x, y + ascent);
-            }
-        }
+            paintOsdText(g);
+        }
+        paintErrorMessage(g, currentEntry, currentOldEntry, currentImage, currentErrorLoading, size);
+    }
+
+    /**
+     * Paint an error message
+     * @param g The graphics to paint on
+     * @param imageEntry The current image entry
+     * @param oldImageEntry The old image entry
+     * @param bufferedImage The image being painted
+     * @param currentErrorLoading If there was an error loading the image
+     * @param size The size of the component
+     */
+    private void paintErrorMessage(Graphics g, IImageEntry<?> imageEntry, IImageEntry<?> oldImageEntry,
+            BufferedImage bufferedImage, boolean currentErrorLoading, Dimension size) {
         final String errorMessage;
         // If the new entry is null, then there is no image.
-        if (entry == null) {
+        if (imageEntry == null) {
             if (emptyText == null) {
                 emptyText = tr("No image");
             }
             errorMessage = emptyText;
-        } else if (image == null || !Objects.equals(entry, oldEntry)) {
+        } else if (bufferedImage == null || !Objects.equals(imageEntry, oldImageEntry)) {
             // The image is not necessarily null when loading anymore. If the oldEntry is not the same as the new entry,
             // we are probably still loading the image. (oldEntry gets set to entry when the image finishes loading).
-            if (!errorLoading) {
-                errorMessage = tr("Loading {0}", entry.getDisplayName());
+            if (!currentErrorLoading) {
+                errorMessage = tr("Loading {0}", imageEntry.getDisplayName());
             } else {
-                errorMessage = tr("Error on file {0}", entry.getDisplayName());
+                errorMessage = tr("Error on file {0}", imageEntry.getDisplayName());
             }
         } else {
@@ -831 +777 @@
     }
 
+    /**
+     * Paint OSD text
+     * @param g The graphics to paint on
+     */
+    private void paintOsdText(Graphics g) {
+        if (osdText != null) {
+            FontMetrics metrics = g.getFontMetrics(g.getFont());
+            int ascent = metrics.getAscent();
+            Color bkground = new Color(255, 255, 255, 128);
+            int lastPos = 0;
+            int pos = osdText.indexOf('\n');
+            int x = 3;
+            int y = 3;
+            String line;
+            while (pos > 0) {
+                line = osdText.substring(lastPos, pos);
+                Rectangle2D lineSize = metrics.getStringBounds(line, g);
+                g.setColor(bkground);
+                g.fillRect(x, y, (int) lineSize.getWidth(), (int) lineSize.getHeight());
+                g.setColor(Color.black);
+                g.drawString(line, x, y + ascent);
+                y += (int) lineSize.getHeight();
+                lastPos = pos + 1;
+                pos = osdText.indexOf('\n', lastPos);
+            }
+
+            line = osdText.substring(lastPos);
+            Rectangle2D lineSize = g.getFontMetrics(g.getFont()).getStringBounds(line, g);
+            g.setColor(bkground);
+            g.fillRect(x, y, (int) lineSize.getWidth(), (int) lineSize.getHeight());
+            g.setColor(Color.black);
+            g.drawString(line, x, y + ascent);
+        }
+    }
+
+    /**
+     * Paint the selected rectangle
+     * @param g The graphics to paint on
+     * @param target The target area (i.e., the selection)
+     * @param visibleRectTemp The current visible rect
+     * @param size The size of the component
+     */
+    private void paintSelectedRect(Graphics g, Rectangle target, VisRect visibleRectTemp, Dimension size) {
+        if (selectedRect != null) {
+            Point topLeft = img2compCoord(visibleRectTemp, selectedRect.x, selectedRect.y, size);
+            Point bottomRight = img2compCoord(visibleRectTemp,
+                    selectedRect.x + selectedRect.width,
+                    selectedRect.y + selectedRect.height, size);
+            g.setColor(new Color(128, 128, 128, 180));
+            g.fillRect(target.x, target.y, target.width, topLeft.y - target.y);
+            g.fillRect(target.x, target.y, topLeft.x - target.x, target.height);
+            g.fillRect(bottomRight.x, target.y, target.x + target.width - bottomRight.x, target.height);
+            g.fillRect(target.x, bottomRight.y, target.width, target.y + target.height - bottomRight.y);
+            g.setColor(Color.black);
+            g.drawRect(topLeft.x, topLeft.y, bottomRight.x - topLeft.x, bottomRight.y - topLeft.y);
+        }
+    }
+
     static Point img2compCoord(VisRect visibleRect, int xImg, int yImg, Dimension compSize) {
         Rectangle drawRect = calculateDrawImageRectangle(visibleRect, compSize);
@@ -854 +858 @@
     }
 
+    /**
+     * calculateDrawImageRectangle
+     *
+     * @param visibleRect the part of the image that should be drawn (in image coordinates)
+     * @param compSize the part of the component where the image should be drawn (in component coordinates)
+     * @return the part of compRect with the same width/height ratio as the image
+     */
     static VisRect calculateDrawImageRectangle(VisRect visibleRect, Dimension compSize) {
         return calculateDrawImageRectangle(visibleRect, new Rectangle(0, 0, compSize.width, compSize.height));
@@ -907 +918 @@
      */
     public void zoomBestFitOrOne() {
-        ImageEntry entry;
-        Image image;
-        VisRect visibleRect;
+        IImageEntry<?> currentEntry;
+        Image currentImage;
+        VisRect currentVisibleRect;
 
         synchronized (this) {
-            entry = this.entry;
-            image = this.image;
-            visibleRect = this.visibleRect;
-        }
-
-        if (image == null)
+            currentEntry = this.entry;
+            currentImage = this.image;
+            currentVisibleRect = this.visibleRect;
+        }
+
+        if (currentImage == null)
             return;
 
-        if (visibleRect.width != image.getWidth(null) || visibleRect.height != image.getHeight(null)) {
+        if (currentVisibleRect.width != currentImage.getWidth(null) || currentVisibleRect.height != currentImage.getHeight(null)) {
             // The display is not at best fit. => Zoom to best fit
-            visibleRect.reset();
+            currentVisibleRect.reset();
         } else {
             // The display is at best fit => zoom to 1:1
-            Point center = getCenterImgCoord(visibleRect);
-            visibleRect.setBounds(center.x - getWidth() / 2, center.y - getHeight() / 2,
+            Point center = getCenterImgCoord(currentVisibleRect);
+            currentVisibleRect.setBounds(center.x - getWidth() / 2, center.y - getHeight() / 2,
                     getWidth(), getHeight());
-            visibleRect.checkRectSize();
-            visibleRect.checkRectPos();
+            currentVisibleRect.checkRectSize();
+            currentVisibleRect.checkRectPos();
         }
 
         synchronized (this) {
-            if (this.entry == entry) {
-                this.visibleRect = visibleRect;
+            if (this.entry == currentEntry) {
+                this.visibleRect = currentVisibleRect;
             }
         }
         repaint();
     }
+
+    /**
+     * Get the image viewer for an entry
+     * @param entry The entry to get the viewer for. May be {@code null}.
+     * @return The new image viewer, may be {@code null}
+     */
+    private IImageViewer getIImageViewer(IImageEntry<?> entry) {
+        IImageViewer imageViewer;
+        IImageEntry<?> imageEntry;
+        synchronized (this) {
+            imageViewer = this.iImageViewer;
+            imageEntry = entry == null ? this.entry : entry;
+        }
+        if (imageEntry == null || (imageViewer != null && imageViewer.getSupportedProjections().contains(imageEntry.getProjectionType()))) {
+            return imageViewer;
+        }
+        try {
+            imageViewer = ImageProjectionRegistry.getViewer(imageEntry.getProjectionType()).getConstructor().newInstance();
+        } catch (ReflectiveOperationException e) {
+            throw new JosmRuntimeException(e);
+        }
+        synchronized (this) {
+            if (imageEntry.equals(this.entry)) {
+                this.removeComponentListener(this.iImageViewer);
+                this.iImageViewer = imageViewer;
+                imageViewer.componentResized(new ComponentEvent(this, ComponentEvent.COMPONENT_RESIZED));
+                this.addComponentListener(this.iImageViewer);
+            }
+        }
+        return imageViewer;
+    }
+
+    /**
+     * Ensure that a rectangle isn't zoomed in too much
+     * @param rectangle The rectangle to get (typically the visible area)
+     */
+    private void ensureMaxZoom(final Rectangle rectangle) {
+        if (rectangle.width < getSize().width / MAX_ZOOM.get()) {
+            rectangle.width = (int) (getSize().width / MAX_ZOOM.get());
+        }
+        if (rectangle.height < getSize().height / MAX_ZOOM.get()) {
+            rectangle.height = (int) (getSize().height / MAX_ZOOM.get());
+        }
+
+        // Set the same ratio for the visible rectangle and the display area
+        int hFact = rectangle.height * getSize().width;
+        int wFact = rectangle.width * getSize().height;
+        if (hFact > wFact) {
+            rectangle.width = hFact / getSize().height;
+        } else {
+            rectangle.height = wFact / getSize().width;
+        }
+    }
+
+    /**
+     * Update the visible rectangle (ensure zoom does not exceed specified values).
+     * Specifically only visible for {@link IImageViewer} implementations.
+     * @since 18246
+     */
+    public void updateVisibleRectangle() {
+        final VisRect currentVisibleRect;
+        final Image mouseImage;
+        final IImageViewer iImageViewer;
+        synchronized (this) {
+            currentVisibleRect = this.visibleRect;
+            mouseImage = this.image;
+            iImageViewer = this.getIImageViewer(this.entry);
+        }
+        if (mouseImage != null && currentVisibleRect != null && iImageViewer != null) {
+            final Image maxImageSize = iImageViewer.getMaxImageSize(this, mouseImage);
+            final VisRect maxVisibleRect = new VisRect(0, 0, maxImageSize.getWidth(null), maxImageSize.getHeight(null));
+            maxVisibleRect.setRect(currentVisibleRect);
+            ensureMaxZoom(maxVisibleRect);
+
+            maxVisibleRect.checkRectSize();
+            synchronized (this) {
+                this.visibleRect = maxVisibleRect;
+            }
+        }
+    }
 }

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

@@ -16 +16 @@
 import java.util.Collections;
 import java.util.Objects;
-
 import javax.imageio.IIOParam;
 import javax.imageio.ImageReadParam;
@@ -23 +22 @@
 import org.openstreetmap.josm.data.ImageData;
 import org.openstreetmap.josm.data.gpx.GpxImageEntry;
+import org.openstreetmap.josm.data.imagery.street_level.IImageEntry;
 import org.openstreetmap.josm.tools.ExifReader;
 import org.openstreetmap.josm.tools.ImageProvider;
@@ -31 +31 @@
  * @since 2662
  */
-public class ImageEntry extends GpxImageEntry {
+public class ImageEntry extends GpxImageEntry implements IImageEntry<ImageEntry> {
 
     private Image thumbnail;
@@ -136 +136 @@
     }
 
+    @Override
+    public ImageEntry getNextImage() {
+        return this.dataSet.getNextImage();
+    }
+
+    @Override
+    public void selectNextImage(final ImageViewerDialog imageViewerDialog) {
+        IImageEntry.super.selectNextImage(imageViewerDialog);
+        this.dataSet.setSelectedImage(this.getNextImage());
+    }
+
+    @Override
+    public ImageEntry getPreviousImage() {
+        return this.dataSet.getPreviousImage();
+    }
+
+    @Override
+    public void selectPreviousImage(ImageViewerDialog imageViewerDialog) {
+        IImageEntry.super.selectPreviousImage(imageViewerDialog);
+        this.dataSet.setSelectedImage(this.getPreviousImage());
+    }
+
+    @Override
+    public ImageEntry getFirstImage() {
+        return this.dataSet.getFirstImage();
+    }
+
+    @Override
+    public void selectFirstImage(ImageViewerDialog imageViewerDialog) {
+        IImageEntry.super.selectFirstImage(imageViewerDialog);
+        this.dataSet.setSelectedImage(this.getFirstImage());
+    }
+
+    @Override
+    public ImageEntry getLastImage() {
+        return this.dataSet.getLastImage();
+    }
+
+    @Override
+    public void selectLastImage(ImageViewerDialog imageViewerDialog) {
+        IImageEntry.super.selectLastImage(imageViewerDialog);
+        this.dataSet.setSelectedImage(this.getLastImage());
+    }
+
+    @Override
+    public boolean isRemoveSupported() {
+        return true;
+    }
+
+    @Override
+    public boolean remove() {
+        this.dataSet.removeImage(this, false);
+        return true;
+    }
+
     /**
      * Reads the image represented by this entry in the given target dimension.
@@ -142 +197 @@
      * @throws IOException if any I/O error occurs
      */
+    @Override
     public BufferedImage read(Dimension target) throws IOException {
         URL imageUrl = getImageUrl();

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

@@ -16 +16 @@
 import java.time.format.DateTimeFormatter;
 import java.time.format.FormatStyle;
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
 import java.util.concurrent.Future;
-
+import java.util.stream.Collectors;
 import javax.swing.AbstractAction;
 import javax.swing.Box;
@@ -33 +34 @@
 import org.openstreetmap.josm.data.ImageData;
 import org.openstreetmap.josm.data.ImageData.ImageDataUpdateListener;
+import org.openstreetmap.josm.data.imagery.street_level.IImageEntry;
 import org.openstreetmap.josm.gui.ExtendedDialog;
 import org.openstreetmap.josm.gui.MainApplication;
 import org.openstreetmap.josm.gui.datatransfer.ClipboardUtils;
-import org.openstreetmap.josm.gui.dialogs.DialogsPanel.Action;
+import org.openstreetmap.josm.gui.dialogs.DialogsPanel;
 import org.openstreetmap.josm.gui.dialogs.ToggleDialog;
 import org.openstreetmap.josm.gui.dialogs.layer.LayerVisibilityAction;
@@ -50 +52 @@
 import org.openstreetmap.josm.tools.Logging;
 import org.openstreetmap.josm.tools.Shortcut;
-import org.openstreetmap.josm.tools.Utils;
 import org.openstreetmap.josm.tools.date.DateUtils;
 
@@ -221 +222 @@
         @Override
         public void actionPerformed(ActionEvent e) {
-            if (currentData != null) {
-                currentData.selectNextImage();
+            if (ImageViewerDialog.this.currentEntry != null) {
+                ImageViewerDialog.this.currentEntry.selectNextImage(ImageViewerDialog.this);
             }
         }
@@ -236 +237 @@
         @Override
         public void actionPerformed(ActionEvent e) {
-            if (currentData != null) {
-                currentData.selectPreviousImage();
+            if (ImageViewerDialog.this.currentEntry != null) {
+                ImageViewerDialog.this.currentEntry.selectPreviousImage(ImageViewerDialog.this);
             }
         }
@@ -251 +252 @@
         @Override
         public void actionPerformed(ActionEvent e) {
-            if (currentData != null) {
-                currentData.selectFirstImage();
+            if (ImageViewerDialog.this.currentEntry != null) {
+                ImageViewerDialog.this.currentEntry.selectFirstImage(ImageViewerDialog.this);
             }
         }
@@ -266 +267 @@
         @Override
         public void actionPerformed(ActionEvent e) {
-            if (currentData != null) {
-                currentData.selectLastImage();
+            if (ImageViewerDialog.this.currentEntry != null) {
+                ImageViewerDialog.this.currentEntry.selectLastImage(ImageViewerDialog.this);
             }
         }
@@ -309 +310 @@
         @Override
         public void actionPerformed(ActionEvent e) {
-            if (currentData != null) {
-                currentData.removeSelectedImages();
+            if (ImageViewerDialog.this.currentEntry != null) {
+                IImageEntry<?> imageEntry = ImageViewerDialog.this.currentEntry;
+                if (imageEntry.isRemoveSupported()) {
+                    imageEntry.remove();
+                }
             }
         }
@@ -325 +329 @@
         @Override
         public void actionPerformed(ActionEvent e) {
-            if (currentData != null && currentData.getSelectedImage() != null) {
-                List<ImageEntry> toDelete = currentData.getSelectedImages();
+            if (currentEntry != null) {
+                List<IImageEntry<?>> toDelete = currentEntry instanceof ImageEntry ?
+                        new ArrayList<>(((ImageEntry) currentEntry).getDataSet().getSelectedImages())
+                        : Collections.singletonList(currentEntry);
                 int size = toDelete.size();
 
@@ -347 +353 @@
 
                 if (result == 2) {
-                    for (ImageEntry delete : toDelete) {
-                        if (Utils.deleteFile(delete.getFile())) {
-                            currentData.removeImage(delete, false);
+                    final List<ImageData> imageDataCollection = toDelete.stream().filter(ImageEntry.class::isInstance)
+                            .map(ImageEntry.class::cast).map(ImageEntry::getDataSet).distinct().collect(Collectors.toList());
+                    for (IImageEntry<?> delete : toDelete) {
+                        if (delete.isRemoveSupported() && delete.remove()) {
                             Logging.info("File {0} deleted.", delete.getFile());
                         } else {
@@ -360 +367 @@
                         }
                     }
-                    currentData.notifyImageUpdate();
-                    currentData.updateSelectedImage();
+                    imageDataCollection.forEach(data -> {
+                        data.notifyImageUpdate();
+                        data.updateSelectedImage();
+                    });
                 }
             }
@@ -376 +385 @@
         @Override
         public void actionPerformed(ActionEvent e) {
-            if (currentData != null) {
-                ClipboardUtils.copyString(String.valueOf(currentData.getSelectedImage().getFile()));
+            if (currentEntry != null) {
+                ClipboardUtils.copyString(String.valueOf(currentEntry.getFile()));
             }
         }
@@ -426 +435 @@
     }
 
-    private transient ImageData currentData;
-    private transient ImageEntry currentEntry;
+    private transient IImageEntry<?> currentEntry;
 
     /**
      * Displays a single image for the given layer.
-     * @param data the image data
+     * @param ignoredData the image data
      * @param entry image entry
      * @see #displayImages
      */
-    public void displayImage(ImageData data, ImageEntry entry) {
-        displayImages(data, Collections.singletonList(entry));
+    public void displayImage(ImageData ignoredData, ImageEntry entry) {
+        displayImages(Collections.singletonList(entry));
+    }
+
+    /**
+     * Displays a single image for the given layer.
+     * @param entry image entry
+     * @see #displayImages
+     */
+    public void displayImage(IImageEntry<?> entry) {
+        this.displayImages(Collections.singletonList(entry));
     }
 
     /**
      * Displays images for the given layer.
-     * @param data the image data
      * @param entries image entries
-     * @since 15333
-     */
-    public void displayImages(ImageData data, List<ImageEntry> entries) {
+     * @since 18246
+     */
+    public void displayImages(List<IImageEntry<?>> entries) {
         boolean imageChanged;
-        ImageEntry entry = entries != null && entries.size() == 1 ? entries.get(0) : null;
+        IImageEntry<?> entry = entries != null && entries.size() == 1 ? entries.get(0) : null;
 
         synchronized (this) {
@@ -458 +474 @@
             }
 
-            currentData = data;
             currentEntry = entry;
         }
 
         if (entry != null) {
-            setNextEnabled(data.hasNextImage());
-            setPreviousEnabled(data.hasPreviousImage());
-            btnDelete.setEnabled(true);
-            btnDeleteFromDisk.setEnabled(entry.getFile() != null);
-            btnCopyPath.setEnabled(true);
-
-            if (imageChanged) {
-                cancelLoadingImage();
-                // Set only if the image is new to preserve zoom and position if the same image is redisplayed
-                // (e.g. to update the OSD).
-                imgLoadingFuture = imgDisplay.setImage(entry);
-            }
-            setTitle(tr("Geotagged Images") + (!entry.getDisplayName().isEmpty() ? " - " + entry.getDisplayName() : ""));
-            StringBuilder osd = new StringBuilder(entry.getDisplayName());
-            if (entry.getElevation() != null) {
-                osd.append(tr("\nAltitude: {0} m", Math.round(entry.getElevation())));
-            }
-            if (entry.getSpeed() != null) {
-                osd.append(tr("\nSpeed: {0} km/h", Math.round(entry.getSpeed())));
-            }
-            if (entry.getExifImgDir() != null) {
-                osd.append(tr("\nDirection {0}\u00b0", Math.round(entry.getExifImgDir())));
-            }
-
-            DateTimeFormatter dtf = DateUtils.getDateTimeFormatter(FormatStyle.SHORT, FormatStyle.MEDIUM)
-                    // Set timezone to UTC since UTC is assumed when parsing the EXIF timestamp,
-                    // see see org.openstreetmap.josm.tools.ExifReader.readTime(com.drew.metadata.Metadata)
-                    .withZone(ZoneOffset.UTC);
-
-            if (entry.hasExifTime()) {
-                osd.append(tr("\nEXIF time: {0}", dtf.format(entry.getExifInstant())));
-            }
-            if (entry.hasGpsTime()) {
-                osd.append(tr("\nGPS time: {0}", dtf.format(entry.getGpsInstant())));
-            }
-            Optional.ofNullable(entry.getIptcCaption()).map(s -> tr("\nCaption: {0}", s)).ifPresent(osd::append);
-            Optional.ofNullable(entry.getIptcHeadline()).map(s -> tr("\nHeadline: {0}", s)).ifPresent(osd::append);
-            Optional.ofNullable(entry.getIptcKeywords()).map(s -> tr("\nKeywords: {0}", s)).ifPresent(osd::append);
-            Optional.ofNullable(entry.getIptcObjectName()).map(s -> tr("\nObject name: {0}", s)).ifPresent(osd::append);
-
-            imgDisplay.setOsdText(osd.toString());
+            this.updateButtonsNonNullEntry(entry, imageChanged);
         } else {
-            boolean hasMultipleImages = entries != null && entries.size() > 1;
-            // if this method is called to reinitialize dialog content with a blank image,
-            // do not actually show the dialog again with a blank image if currently hidden (fix #10672)
-            setTitle(tr("Geotagged Images"));
-            imgDisplay.setImage(null);
-            imgDisplay.setOsdText("");
-            setNextEnabled(false);
-            setPreviousEnabled(false);
-            btnDelete.setEnabled(hasMultipleImages);
-            btnDeleteFromDisk.setEnabled(hasMultipleImages);
-            btnCopyPath.setEnabled(false);
-            if (hasMultipleImages) {
-                imgDisplay.setEmptyText(tr("Multiple images selected"));
-                btnFirst.setEnabled(!isFirstImageSelected(data));
-                btnLast.setEnabled(!isLastImageSelected(data));
-            }
-            imgDisplay.setImage(null);
-            imgDisplay.setOsdText("");
+            this.updateButtonsNullEntry(entries);
             return;
         }
         if (!isDialogShowing()) {
-            setIsDocked(false);     // always open a detached window when an image is clicked and dialog is closed
+            setIsDocked(false); // always open a detached window when an image is clicked and dialog is closed
             showDialog();
-        } else {
-            if (isDocked && isCollapsed) {
-                expand();
-                dialogsPanel.reconstruct(Action.COLLAPSED_TO_DEFAULT, this);
-            }
-        }
-    }
-
-    private static boolean isLastImageSelected(ImageData data) {
-        return data.isImageSelected(data.getImages().get(data.getImages().size() - 1));
-    }
-
-    private static boolean isFirstImageSelected(ImageData data) {
-        return data.isImageSelected(data.getImages().get(0));
+        } else if (isDocked && isCollapsed) {
+            expand();
+            dialogsPanel.reconstruct(DialogsPanel.Action.COLLAPSED_TO_DEFAULT, this);
+        }
+    }
+
+    /**
+     * Update buttons for null entry
+     * @param entries {@code true} if multiple images are selected
+     */
+    private void updateButtonsNullEntry(List<IImageEntry<?>> entries) {
+        boolean hasMultipleImages = entries != null && entries.size() > 1;
+        // if this method is called to reinitialize dialog content with a blank image,
+        // do not actually show the dialog again with a blank image if currently hidden (fix #10672)
+        setTitle(tr("Geotagged Images"));
+        imgDisplay.setImage(null);
+        imgDisplay.setOsdText("");
+        setNextEnabled(false);
+        setPreviousEnabled(false);
+        btnDelete.setEnabled(hasMultipleImages);
+        btnDeleteFromDisk.setEnabled(hasMultipleImages);
+        btnCopyPath.setEnabled(false);
+        if (hasMultipleImages) {
+            imgDisplay.setEmptyText(tr("Multiple images selected"));
+            btnFirst.setEnabled(!isFirstImageSelected(entries));
+            btnLast.setEnabled(!isLastImageSelected(entries));
+        }
+        imgDisplay.setImage(null);
+        imgDisplay.setOsdText("");
+    }
+
+    /**
+     * Update the image viewer buttons for the new entry
+     * @param entry The new entry
+     * @param imageChanged {@code true} if it is not the same image as the previous image.
+     */
+    private void updateButtonsNonNullEntry(IImageEntry<?> entry, boolean imageChanged) {
+        setNextEnabled(entry.getNextImage() != null);
+        setPreviousEnabled(entry.getPreviousImage() != null);
+        btnDelete.setEnabled(true);
+        btnDeleteFromDisk.setEnabled(entry.getFile() != null);
+        btnCopyPath.setEnabled(true);
+
+        if (imageChanged) {
+            cancelLoadingImage();
+            // Set only if the image is new to preserve zoom and position if the same image is redisplayed
+            // (e.g. to update the OSD).
+            imgLoadingFuture = imgDisplay.setImage(entry);
+        }
+        setTitle(tr("Geotagged Images") + (!entry.getDisplayName().isEmpty() ? " - " + entry.getDisplayName() : ""));
+        StringBuilder osd = new StringBuilder(entry.getDisplayName());
+        if (entry.getElevation() != null) {
+            osd.append(tr("\nAltitude: {0} m", Math.round(entry.getElevation())));
+        }
+        if (entry.getSpeed() != null) {
+            osd.append(tr("\nSpeed: {0} km/h", Math.round(entry.getSpeed())));
+        }
+        if (entry.getExifImgDir() != null) {
+            osd.append(tr("\nDirection {0}\u00b0", Math.round(entry.getExifImgDir())));
+        }
+
+        DateTimeFormatter dtf = DateUtils.getDateTimeFormatter(FormatStyle.SHORT, FormatStyle.MEDIUM)
+                // Set timezone to UTC since UTC is assumed when parsing the EXIF timestamp,
+                // see see org.openstreetmap.josm.tools.ExifReader.readTime(com.drew.metadata.Metadata)
+                .withZone(ZoneOffset.UTC);
+
+        if (entry.hasExifTime()) {
+            osd.append(tr("\nEXIF time: {0}", dtf.format(entry.getExifInstant())));
+        }
+        if (entry.hasGpsTime()) {
+            osd.append(tr("\nGPS time: {0}", dtf.format(entry.getGpsInstant())));
+        }
+        Optional.ofNullable(entry.getIptcCaption()).map(s -> tr("\nCaption: {0}", s)).ifPresent(osd::append);
+        Optional.ofNullable(entry.getIptcHeadline()).map(s -> tr("\nHeadline: {0}", s)).ifPresent(osd::append);
+        Optional.ofNullable(entry.getIptcKeywords()).map(s -> tr("\nKeywords: {0}", s)).ifPresent(osd::append);
+        Optional.ofNullable(entry.getIptcObjectName()).map(s -> tr("\nObject name: {0}", s)).ifPresent(osd::append);
+
+        imgDisplay.setOsdText(osd.toString());
+    }
+
+    /**
+     * Displays images for the given layer.
+     * @param ignoredData the image data (unused, may be {@code null})
+     * @param entries image entries
+     * @since 18246 (signature)
+     * @deprecated Use {@link #displayImages(List)} (The data param is no longer used)
+     */
+    @Deprecated
+    public void displayImages(ImageData ignoredData, List<IImageEntry<?>> entries) {
+        this.displayImages(entries);
+    }
+
+    private static boolean isLastImageSelected(List<IImageEntry<?>> data) {
+        return data.stream().anyMatch(image -> data.contains(image.getLastImage()));
+    }
+
+    private static boolean isFirstImageSelected(List<IImageEntry<?>> data) {
+        return data.stream().anyMatch(image -> data.contains(image.getFirstImage()));
     }
 
@@ -576 +618 @@
      * Returns the currently displayed image.
      * @return Currently displayed image or {@code null}
-     * @since 6392
-     */
-    public static ImageEntry getCurrentImage() {
+     * @since 18246 (signature)
+     */
+    public static IImageEntry<?> getCurrentImage() {
         return getInstance().currentEntry;
     }
@@ -599 +641 @@
     @Override
     public void layerRemoving(LayerRemoveEvent e) {
-        if (e.getRemovedLayer() instanceof GeoImageLayer) {
+        if (e.getRemovedLayer() instanceof GeoImageLayer && this.currentEntry instanceof ImageEntry) {
             ImageData removedData = ((GeoImageLayer) e.getRemovedLayer()).getImageData();
-            if (removedData == currentData) {
-                displayImages(null, null);
+            if (removedData == ((ImageEntry) this.currentEntry).getDataSet()) {
+                displayImages(null);
             }
             removedData.removeImageDataUpdateListener(this);
@@ -627 +669 @@
 
     private void showLayer(Layer newLayer) {
-        if (currentData == null && newLayer instanceof GeoImageLayer) {
-            ((GeoImageLayer) newLayer).getImageData().selectFirstImage();
+        if (this.currentEntry == null && newLayer instanceof GeoImageLayer) {
+            ImageData imageData = ((GeoImageLayer) newLayer).getImageData();
+            imageData.setSelectedImage(imageData.getFirstImage());
         }
     }
@@ -641 +684 @@
     @Override
     public void selectedImageChanged(ImageData data) {
-        displayImages(data, data.getSelectedImages());
+        displayImages(new ArrayList<>(data.getSelectedImages()));
     }
 
     @Override
     public void imageDataUpdated(ImageData data) {
-        displayImages(data, data.getSelectedImages());
+        displayImages(new ArrayList<>(data.getSelectedImages()));
     }
 }