Ticket #12934: patch-mapview-add-state-class.patch

new file src/org/openstreetmap/josm/gui/MapViewState.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.gui;
+
+import java.awt.Point;
+import java.awt.geom.Point2D;
+import java.awt.geom.Point2D.Double;
+
+import javax.swing.SwingUtilities;
+
+import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.data.Bounds;
+import org.openstreetmap.josm.data.ProjectionBounds;
+import org.openstreetmap.josm.data.coor.EastNorth;
+import org.openstreetmap.josm.data.coor.LatLon;
+import org.openstreetmap.josm.data.projection.Projection;
+
+/**
+ * This class represents a state of the {@link MapView}.
+ * @author Michael Zangl
+ * @since xxx
+ */
+public class MapViewState {
+
+    private final Projection projection = Main.getProjection();
+
+    private final int viewWidth;
+    private final int viewHeight;
+
+    private final double scale;
+
+    /**
+     * Top left {@link EastNorth} coordinate of the view.
+     */
+    private final EastNorth topLeft;
+
+    private final NavigatableComponent navigatableComponent;
+
+    /**
+     * Create a new {@link MapViewState} object for the given map view.
+     * @param navigatableComponent The view.
+     */
+    public MapViewState(NavigatableComponent navigatableComponent) {
+        this.navigatableComponent = navigatableComponent;
+        viewWidth = navigatableComponent.getWidth();
+        viewHeight = navigatableComponent.getHeight();
+
+        scale = navigatableComponent.getScale();
+        EastNorth center = navigatableComponent.getCenter();
+        topLeft = new EastNorth(center.east() - viewWidth / 2.0 * scale, center.north() + viewHeight / 2.0 * scale);
+    }
+
+    /**
+     * Gets the MapViewPoint representation for a position in view coordinates.
+     * @param x The x coordinate inside the view.
+     * @param y The y coordinate inside the view.
+     * @return The MapViewPoint.
+     */
+    public MapViewPoint getForView(double x, double y) {
+        return new MapViewViewPoint(x, y);
+    }
+
+    /**
+     * Gets the {@link MapViewPoint} for the given {@link EastNorth} coordinate.
+     * @param eastNorth the position.
+     * @return The point for that position.
+     */
+    public MapViewPoint getPointFor(EastNorth eastNorth) {
+        return new MapViewEastNorthPoint(eastNorth);
+    }
+
+    /**
+     * Gets a rectangle representing the whole view area.
+     * @return The rectangle.
+     */
+    public MapViewRectangle getViewArea() {
+        return getForView(0, 0).rectTo(getForView(viewWidth, viewHeight));
+    }
+
+    /**
+     * Gets the center of the view.
+     * @return The center position.
+     */
+    public MapViewPoint getCenter() {
+        return getForView(viewWidth / 2.0, viewHeight / 2.0);
+    }
+
+    /**
+     * Gets the width of the view on the Screen;
+     * @return The width of the view component in screen pixel.
+     */
+    public double getViewWidth() {
+        return viewWidth;
+    }
+
+    /**
+     * Gets the height of the view on the Screen;
+     * @return The height of the view component in screen pixel.
+     */
+    public double getViewHeight() {
+        return viewHeight;
+    }
+
+    /**
+     * Gets the current projection used for the MapView.
+     * @return The projection.
+     */
+    public Projection getProjection() {
+        return projection;
+    }
+
+    /**
+     * A class representing a point in the map view. It allws to convert between the different coordinate systems.
+     * @author Michael Zangl
+     * @since xxx
+     */
+    public abstract class MapViewPoint {
+
+        /**
+         * Get this point in view coordinates.
+         * @return The point in view coordinates.
+         */
+        public Point2D getInView() {
+            return new Point2D.Double(getInViewX(), getInViewY());
+        }
+
+        protected abstract double getInViewX();
+
+        protected abstract double getInViewY();
+
+        /**
+         * Convert this point to window coordinates.
+         * @return The point in window coordinates.
+         */
+        public Point2D getInWindow() {
+            Point corner = SwingUtilities.convertPoint(navigatableComponent, new Point(0, 0), null);
+            return getUsingCorner(corner);
+        }
+
+        /**
+         * Convert this point to screen coordinates.
+         * @return The point in screen coordinates.
+         */
+        public Point2D getOnScreen() {
+            Point corner = new Point(0, 0);
+            SwingUtilities.convertPointToScreen(corner, navigatableComponent);
+            return getUsingCorner(corner);
+        }
+
+        private Double getUsingCorner(Point corner) {
+            return new Point2D.Double(corner.getX() + getInViewX(), corner.getY() + getInViewY());
+        }
+
+        /**
+         * Gets the {@link EastNorth} coordinate of this point.
+         * @return The east/north coordinate.
+         */
+        public EastNorth getEastNorth() {
+            return new EastNorth(topLeft.east() + getInViewX() * scale, topLeft.north() - getInViewY() * scale);
+        }
+
+        /**
+         * Create a rectangle from this to the other point.
+         * @param other The other point. Needs to be of the same {@link MapViewState}
+         * @return A rectangle.
+         */
+        public MapViewRectangle rectTo(MapViewPoint other) {
+            return new MapViewRectangle(this, other);
+        }
+
+        /**
+         * Gets the current position in LatLon coordinates according to the current projection.
+         * @return The positon as LatLon.
+         */
+        public LatLon getLatLon() {
+            return projection.eastNorth2latlon(getEastNorth());
+        }
+
+    }
+
+    private class MapViewViewPoint extends MapViewPoint {
+        private final double x;
+        private final double y;
+
+        MapViewViewPoint(double x, double y) {
+            this.x = x;
+            this.y = y;
+        }
+
+        @Override
+        protected double getInViewX() {
+            return x;
+        }
+
+        @Override
+        protected double getInViewY() {
+            return y;
+        }
+
+        @Override
+        public String toString() {
+            return "MapViewViewPoint [x=" + x + ", y=" + y + "]";
+        }
+    }
+
+    private class MapViewEastNorthPoint extends MapViewPoint {
+
+        private final EastNorth eastNorth;
+
+        MapViewEastNorthPoint(EastNorth eastNorth) {
+            this.eastNorth = eastNorth;
+        }
+
+        @Override
+        protected double getInViewX() {
+            return (eastNorth.east() - topLeft.east()) / scale;
+        }
+
+        @Override
+        protected double getInViewY() {
+            return (topLeft.north() - eastNorth.north()) / scale;
+        }
+
+        @Override
+        public EastNorth getEastNorth() {
+            return eastNorth;
+        }
+
+        @Override
+        public String toString() {
+            return "MapViewEastNorthPoint [eastNorth=" + eastNorth + "]";
+        }
+
+    }
+
+    /**
+     * A rectangle on the MapView. It is rectangular in screen / EastNorth space.
+     * @author Michael Zangl
+     * @since xxx
+     */
+    public class MapViewRectangle {
+        private final MapViewPoint p1;
+        private final MapViewPoint p2;
+
+        /**
+         * Create a new MapViewRectangle
+         * @param p1 The first point to use
+         * @param p2 The second point to use.
+         */
+        MapViewRectangle(MapViewPoint p1, MapViewPoint p2) {
+            super();
+            this.p1 = p1;
+            this.p2 = p2;
+        }
+
+        /**
+         * Gets the projection bounds for this rectangle.
+         * @return The projection bounds.
+         */
+        public ProjectionBounds getProjectionBounds() {
+            ProjectionBounds b = new ProjectionBounds(p1.getEastNorth());
+            b.extend(p2.getEastNorth());
+            return b;
+        }
+
+        /**
+         * Gets a rough estimate of the bounds by assuming lat/lon are parallel to x/y.
+         * @return The bounds computed by converting the corners of this rectangle.
+         */
+        public Bounds getCornerBounds() {
+            Bounds b = new Bounds(p1.getLatLon());
+            b.extend(p2.getLatLon());
+            return b;
+        }
+    }
+
+}

src/org/openstreetmap/josm/gui/NavigatableComponent.java

@@ -49 +49 @@
 import org.openstreetmap.josm.data.preferences.IntegerProperty;
 import org.openstreetmap.josm.data.projection.Projection;
 import org.openstreetmap.josm.data.projection.Projections;
+import org.openstreetmap.josm.gui.MapViewState.MapViewPoint;
 import org.openstreetmap.josm.gui.download.DownloadDialog;
 import org.openstreetmap.josm.gui.help.Helpful;
 import org.openstreetmap.josm.gui.layer.NativeScaleLayer;
@@ -393 +394 @@
     }
 
     public ProjectionBounds getProjectionBounds() {
-        return new ProjectionBounds(
-                new EastNorth(
-                        center.east() - getWidth()/2.0*scale,
-                        center.north() - getHeight()/2.0*scale),
-                        new EastNorth(
-                                center.east() + getWidth()/2.0*scale,
-                                center.north() + getHeight()/2.0*scale));
+        return new MapViewState(this).getViewArea().getProjectionBounds();
     }
 
     /* FIXME: replace with better method - used by MapSlider */
@@ -411 +406 @@
 
     /* FIXME: replace with better method - used by Main to reset Bounds when projection changes, don't use otherwise */
     public Bounds getRealBounds() {
-        return new Bounds(
-                getProjection().eastNorth2latlon(new EastNorth(
-                        center.east() - getWidth()/2.0*scale,
-                        center.north() - getHeight()/2.0*scale)),
-                        getProjection().eastNorth2latlon(new EastNorth(
-                                center.east() + getWidth()/2.0*scale,
-                                center.north() + getHeight()/2.0*scale)));
+        return new MapViewState(this).getViewArea().getCornerBounds();
     }
 
     /**
@@ -436 +425 @@
     }
 
     public ProjectionBounds getProjectionBounds(Rectangle r) {
-        EastNorth p1 = getEastNorth(r.x, r.y);
-        EastNorth p2 = getEastNorth(r.x + r.width, r.y + r.height);
-        ProjectionBounds pb = new ProjectionBounds(p1);
-        pb.extend(p2);
-        return pb;
+        MapViewState state = new MapViewState(this);
+        MapViewPoint p1 = state.getForView(r.getMinX(), r.getMinY());
+        MapViewPoint p2 = state.getForView(r.getMaxX(), r.getMaxY());
+        return p1.rectTo(p2).getProjectionBounds();
     }
 
     /**

new file test/unit/org/openstreetmap/josm/gui/MapViewStateTest.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.gui;
+
+import static org.junit.Assert.assertEquals;
+
+import java.awt.Rectangle;
+
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.openstreetmap.josm.JOSMFixture;
+import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.data.coor.EastNorth;
+import org.openstreetmap.josm.data.coor.LatLon;
+import org.openstreetmap.josm.gui.MapViewState.MapViewPoint;
+import org.openstreetmap.josm.gui.util.GuiHelper;
+
+/**
+ * Test {@link MapViewState}
+ * @author Michael Zangl
+ * @since xxx
+ */
+public class MapViewStateTest {
+
+    private static final int HEIGHT = 200;
+    private static final int WIDTH = 300;
+    private NavigatableComponent component;
+    private MapViewState state;
+
+    /**
+     * Setup test.
+     */
+    @BeforeClass
+    public static void setUpBeforeClass() {
+        JOSMFixture.createUnitTestFixture().init();
+    }
+
+    /**
+     * Create a new, fresh {@link NavigatableComponent}
+     */
+    @Before
+    public void setUp() {
+        component = new NavigatableComponent();
+        component.setBounds(new Rectangle(WIDTH, HEIGHT));
+        // wait for the event to be propagated.
+        GuiHelper.runInEDTAndWait(new Runnable() {
+            @Override
+            public void run() {
+            }
+        });
+        state = new MapViewState(component);
+    }
+
+    /**
+     * Test {@link MapViewState#getCenter()} returns map view center.
+     */
+    @Test
+    public void testGetCenter() {
+        MapViewPoint center = state.getCenter();
+        assertHasViewCoords(WIDTH / 2, HEIGHT / 2, center);
+
+        component.zoomTo(new LatLon(3, 4));
+
+        // state should not change, but new state should.
+        center = state.getCenter();
+        assertHasViewCoords(WIDTH / 2, HEIGHT / 2, center);
+
+        center = new MapViewState(component).getCenter();
+        assertEquals("x", 3, center.getLatLon().lat(), 0.01);
+        assertEquals("y", 4, center.getLatLon().lon(), 0.01);
+    }
+
+    private void assertHasViewCoords(double x, double y, MapViewPoint center) {
+        assertEquals("x", x, center.getInViewX(), 0.01);
+        assertEquals("y", y, center.getInViewY(), 0.01);
+        assertEquals("x", x, center.getInView().getX(), 0.01);
+        assertEquals("y", y, center.getInView().getY(), 0.01);
+    }
+
+    /**
+     * Test {@link MapViewState#getForView(double, double)}
+     */
+    @Test
+    public void testGetForView() {
+        MapViewPoint corner = state.getForView(0, 0);
+        assertHasViewCoords(0, 0, corner);
+
+        MapViewPoint middle = state.getForView(120, 130);
+        assertHasViewCoords(120, 130, middle);
+
+        MapViewPoint fraction = state.getForView(0.12, 0.7);
+        assertHasViewCoords(0.12, 0.7, fraction);
+
+        MapViewPoint negative = state.getForView(-17, -30);
+        assertHasViewCoords(-17, -30, negative);
+    }
+
+    /**
+     * Test {@link MapViewState#getViewWidth()} and {@link MapViewState#getViewHeight()}
+     */
+    @Test
+    public void testGetViewSize() {
+        assertEquals(WIDTH, state.getViewWidth(), 0.01);
+        assertEquals(HEIGHT, state.getViewHeight(), 0.01);
+    }
+
+    /**
+     * Tests that all coordinate conversions for the point work.
+     */
+    @Test
+    public void testPointConversions() {
+        MapViewPoint p = state.getForView(50, 70);
+        assertHasViewCoords(50, 70, p);
+
+        EastNorth eastnorth = p.getEastNorth();
+        EastNorth shouldEastNorth = component.getEastNorth(50, 70);
+        assertEquals("east", shouldEastNorth.east(), eastnorth.east(), 0.01);
+        assertEquals("north", shouldEastNorth.north(), eastnorth.north(), 0.01);
+        MapViewPoint reversed = state.getPointFor(shouldEastNorth);
+        assertHasViewCoords(50, 70, reversed);
+
+        LatLon latlon = p.getLatLon();
+        LatLon shouldLatLon = Main.getProjection().eastNorth2latlon(shouldEastNorth);
+        assertEquals("lat", shouldLatLon.lat(), latlon.lat(), 0.01);
+        assertEquals("lon", shouldLatLon.lon(), latlon.lon(), 0.01);
+
+        MapViewPoint p2 = state.getPointFor(new EastNorth(2, 3));
+        assertEquals("east", 2, p2.getEastNorth().east(), 0.01);
+        assertEquals("north", 3, p2.getEastNorth().north(), 0.01);
+    }
+}