Ticket #6869: jmapviewer.3.diff

File jmapviewer.3.diff, 17.7 KB (added by anonymous, 14 years ago)

  • OsmMercator.java

     
    1818    private static int TILE_SIZE = 256;
    1919    public static final double MAX_LAT = 85.05112877980659;
    2020    public static final double MIN_LAT = -85.05112877980659;
     21    private static double EARTH_RADIUS_KM = 6371;
     22
     23    private static double KMTOM=1000;
     24    private static double MTOKM=1/1000;
     25
     26    public static double kmToMeters(double kmeters) {
     27        return kmeters*KMTOM;
     28    }
     29
     30    public static double metersToKm(double meters) {
     31        return meters*MTOKM;
     32    }
    2133
    2234    public static double radius(int aZoomlevel) {
    2335        return (TILE_SIZE * (1 << aZoomlevel)) / (2.0 * Math.PI);
    … …  
    4355    }
    4456
    4557    /**
     58     * Transform pixelspace to coordinates and get the distance.
     59     *
     60     * @param x1 the first x coordinate
     61     * @param y1 the first y coordinate
     62     * @param x2 the second x coordinate
     63     * @param y2 the second y coordinate
     64     *
     65     * @param zoomLevel the zoom level
     66     * @return the distance
     67     * @author Jason Huntley
     68     */
     69    public static double getDistance(int x1, int y1, int x2, int y2, int zoomLevel) {
     70        double la1 = YToLat(y1, zoomLevel);
     71        double lo1 = XToLon(x1, zoomLevel);
     72        double la2 = YToLat(y2, zoomLevel);
     73        double lo2 = XToLon(x2, zoomLevel);
     74
     75        return getDistance(la1, lo1, la2, lo2);
     76    }
     77
     78    /**
     79     * Gets the distance using Spherical law of cosines.
     80     *
     81     * @param la1 the Latitude in degrees
     82     * @param lo1 the Longitude in degrees
     83     * @param la2 the Latitude from 2nd coordinate in degrees
     84     * @param lo2 the Longitude from 2nd coordinate in degrees
     85     * @return the distance
     86     * @author Jason Huntley
     87     */
     88    public static double getDistance(double la1, double lo1, double la2, double lo2) {
     89        double aStartLat = Math.toRadians(la1);
     90        double aStartLong = Math.toRadians(lo1);
     91        double aEndLat =Math.toRadians(la2);
     92        double aEndLong = Math.toRadians(lo2);
     93
     94        double distance = Math.acos(Math.sin(aStartLat) * Math.sin(aEndLat)
     95                + Math.cos(aStartLat) * Math.cos(aEndLat)
     96                * Math.cos(aEndLong - aStartLong));
     97
     98        return (EARTH_RADIUS_KM * distance);           
     99    }
     100
     101    /**
    46102     * Transform longitude to pixelspace
    47103     *
    48104     * <p>

  • JMapViewer.java

     
    2525import javax.swing.JSlider;
    2626import javax.swing.event.ChangeEvent;
    2727import javax.swing.event.ChangeListener;
     28import javax.swing.event.EventListenerList;
    2829
     30import org.openstreetmap.gui.jmapviewer.events.JMVCommandEvent;
     31import org.openstreetmap.gui.jmapviewer.events.JMVCommandEvent.COMMAND;
     32import org.openstreetmap.gui.jmapviewer.interfaces.JMapViewerEventListener;
    2933import org.openstreetmap.gui.jmapviewer.interfaces.MapMarker;
    3034import org.openstreetmap.gui.jmapviewer.interfaces.MapPolygon;
    3135import org.openstreetmap.gui.jmapviewer.interfaces.MapRectangle;
    … …  
    3640import org.openstreetmap.gui.jmapviewer.tilesources.OsmTileSource;
    3741
    3842/**
    39  * 
     43 *
    4044 * Provides a simple panel that displays pre-rendered map tiles loaded from the
    4145 * OpenStreetMap project.
    42  * 
     46 *
    4347 * @author Jan Peter Stotz
    44  * 
     48 *
    4549 */
    4650public class JMapViewer extends JPanel implements TileLoaderListener {
    4751
    … …  
    117121        tileSource = new OsmTileSource.Mapnik();
    118122        tileController = new TileController(tileSource, tileCache, this);
    119123        mapMarkerList = new LinkedList<MapMarker>();
    120         mapRectangleList = new LinkedList<MapRectangle>();
    121124        mapPolygonList = new LinkedList<MapPolygon>();
     125        mapRectangleList = new LinkedList<MapRectangle>();
    122126        mapMarkersVisible = true;
    123127        mapRectanglesVisible = true;
    124128        mapPolygonsVisible = true;
    … …  
    187191    /**
    188192     * Changes the map pane so that it is centered on the specified coordinate
    189193     * at the given zoom level.
    190      * 
     194     *
    191195     * @param lat
    192196     *            latitude of the specified coordinate
    193197     * @param lon
    … …  
    203207     * Changes the map pane so that the specified coordinate at the given zoom
    204208     * level is displayed on the map at the screen coordinate
    205209     * <code>mapPoint</code>.
    206      * 
     210     *
    207211     * @param mapPoint
    208212     *            point on the map denoted in pixels where the coordinate should
    209213     *            be set
    … …  
    264268            nbElemToCheck += mapPolygonList.size();
    265269        if (nbElemToCheck == 0)
    266270            return;
    267        
     271
    268272        int x_min = Integer.MAX_VALUE;
    269273        int y_min = Integer.MAX_VALUE;
    270274        int x_max = Integer.MIN_VALUE;
    271275        int y_max = Integer.MIN_VALUE;
    272276        int mapZoomMax = tileController.getTileSource().getMaxZoom();
    273        
     277
    274278        if (markers) {
    275279            for (MapMarker marker : mapMarkerList) {
    276280                int x = OsmMercator.LonToX(marker.getLon(), mapZoomMax);
    … …  
    281285                y_min = Math.min(y_min, y);
    282286            }
    283287        }
    284        
     288
    285289        if (rectangles) {
    286290            for (MapRectangle rectangle : mapRectangleList) {
    287291                x_max = Math.max(x_max, OsmMercator.LonToX(rectangle.getBottomRight().getLon(), mapZoomMax));
    … …  
    290294                y_min = Math.min(y_min, OsmMercator.LatToY(rectangle.getBottomRight().getLat(), mapZoomMax));
    291295            }
    292296        }
    293        
     297
    294298        if (polygons) {
    295299            for (MapPolygon polygon : mapPolygonList) {
    296300                for (Coordinate c : polygon.getPoints()) {
    … …  
    303307                }
    304308            }
    305309        }
    306        
     310
    307311        int height = Math.max(0, getHeight());
    308312        int width = Math.max(0, getWidth());
    309313        int newZoom = mapZoomMax;
    … …  
    321325        y /= z;
    322326        setDisplayPosition(x, y, newZoom);
    323327    }
    324    
     328
     329
    325330    /**
    326331     * Sets the displayed map pane and zoom level so that all map markers are
    327332     * visible.
    … …  
    337342    public void setDisplayToFitMapRectangles() {
    338343        setDisplayToFitMapElements(false, true, false);
    339344    }
    340    
     345
    341346    /**
    342347     * Sets the displayed map pane and zoom level so that all map polygons are
    343348     * visible.
    … …  
    347352    }
    348353
    349354    /**
     355     * @return the center
     356     */
     357    public Point getCenter() {
     358        return center;
     359    }
     360
     361    /**
     362     * @param center the center to set
     363     */
     364    public void setCenter(Point center) {
     365        this.center = center;
     366    }
     367
     368    /**
    350369     * Calculates the latitude/longitude coordinate of the center of the
    351370     * currently displayed map area.
    352      * 
     371     *
    353372     * @return latitude / longitude
    354373     */
    355374    public Coordinate getPosition() {
    … …  
    361380    /**
    362381     * Converts the relative pixel coordinate (regarding the top left corner of
    363382     * the displayed map) into a latitude / longitude coordinate
    364      * 
     383     *
    365384     * @param mapPoint
    366385     *            relative pixel coordinate regarding the top left corner of the
    367386     *            displayed map
    … …  
    374393    /**
    375394     * Converts the relative pixel coordinate (regarding the top left corner of
    376395     * the displayed map) into a latitude / longitude coordinate
    377      * 
     396     *
    378397     * @param mapPointX
    379398     * @param mapPointY
    380399     * @return
    … …  
    389408
    390409    /**
    391410     * Calculates the position on the map of a given coordinate
    392      * 
     411     *
    393412     * @param lat
    394413     * @param lon
    395414     * @param checkOutside
    … …  
    410429
    411430    /**
    412431     * Calculates the position on the map of a given coordinate
    413      * 
     432     *
    414433     * @param lat
    415434     * @param lon
    416435     * @return point on the map or <code>null</code> if the point is not visible
    … …  
    421440
    422441    /**
    423442     * Calculates the position on the map of a given coordinate
    424      * 
     443     *
    425444     * @param coord
    426445     * @return point on the map or <code>null</code> if the point is not visible
    427446     */
    … …  
    434453
    435454    /**
    436455     * Calculates the position on the map of a given coordinate
    437      * 
     456     *
    438457     * @param coord
    439458     * @return point on the map or <code>null</code> if the point is not visible
    440459     *         and checkOutside set to <code>true</code>
    … …  
    446465            return null;
    447466    }
    448467
     468    /**
     469     * Gets the meter per pixel.
     470     *
     471     * @return the meter per pixel
     472     * @author Jason Huntley
     473     */
     474    public double getMeterPerPixel() {
     475        Point origin=new Point(5,5);
     476        Point center=new Point(getWidth()/2, getHeight()/2);
     477
     478        double pDistance=center.distance(origin);
     479
     480        Coordinate originCoord=getPosition(origin);
     481        Coordinate centerCoord=getPosition(center);
     482
     483        double kmDistance=OsmMercator.getDistance(originCoord.getLat(), originCoord.getLon(),
     484                centerCoord.getLat(), centerCoord.getLon());
     485
     486        double mDistance=OsmMercator.kmToMeters(kmDistance);
     487
     488        return mDistance/pDistance;
     489    }
     490
    449491    @Override
    450492    protected void paintComponent(Graphics g) {
    451493        super.paintComponent(g);
    … …  
    542584                paintMarker(g, marker);
    543585            }
    544586        }
     587
    545588        paintAttribution(g);
    546589    }
    547590
    … …  
    587630            polygon.paint(g, points);
    588631        }
    589632    }
    590    
     633
    591634    /**
    592635     * Moves the visible map pane.
    593      * 
     636     *
    594637     * @param x
    595638     *            horizontal movement in pixel.
    596639     * @param y
    … …  
    600643        center.x += x;
    601644        center.y += y;
    602645        repaint();
     646        this.fireJMVEvent(new JMVCommandEvent(COMMAND.MOVE, this));
    603647    }
    604648
    605649    /**
    … …  
    645689        tileController.cancelOutstandingJobs(); // Clearing outstanding load
    646690        // requests
    647691        setDisplayPositionByLatLon(mapPoint, zoomPos.getLat(), zoomPos.getLon(), zoom);
     692
     693        this.fireJMVEvent(new JMVCommandEvent(COMMAND.ZOOM, this));
    648694    }
    649695
    650696    public void setZoom(int zoom) {
    … …  
    655701     * Every time the zoom level changes this method is called. Override it in
    656702     * derived implementations for adapting zoom dependent values. The new zoom
    657703     * level can be obtained via {@link #getZoom()}.
    658      * 
     704     *
    659705     * @param oldZoom
    660706     *            the previous zoom level
    661707     */
    … …  
    682728
    683729    /**
    684730     * Enables or disables painting of the {@link MapMarker}
    685      * 
     731     *
    686732     * @param mapMarkersVisible
    687733     * @see #addMapMarker(MapMarker)
    688734     * @see #getMapMarkerList()
    … …  
    763809        mapPolygonList.clear();
    764810        repaint();
    765811    }
    766    
     812
    767813    public void setZoomContolsVisible(boolean visible) {
    768814        zoomSlider.setVisible(visible);
    769815        zoomInButton.setVisible(visible);
    … …  
    808854
    809855    /**
    810856     * Enables or disables painting of the {@link MapRectangle}
    811      * 
     857     *
    812858     * @param mapRectanglesVisible
    813859     * @see #addMapRectangle(MapRectangle)
    814860     * @see #getMapRectangleList()
    … …  
    824870
    825871    /**
    826872     * Enables or disables painting of the {@link MapPolygon}
    827      * 
     873     *
    828874     * @param mapPolygonsVisible
    829875     * @see #addMapPolygon(MapPolygon)
    830876     * @see #getMapPolygonList()
    … …  
    836882
    837883    /*
    838884     * (non-Javadoc)
    839      * 
     885     *
    840886     * @see
    841887     * org.openstreetmap.gui.jmapviewer.interfaces.TileLoaderListener#getTileCache
    842888     * ()
    … …  
    898944
    899945        g.setFont(font);
    900946    }
     947
     948    protected EventListenerList listenerList = new EventListenerList();
     949
     950    /**
     951     * @param listener to set
     952     */
     953    public void addJMVListener(JMapViewerEventListener listener) {
     954        listenerList.add(JMapViewerEventListener.class, listener);
     955    }
     956
     957    /**
     958     * @param listener to remove
     959     */
     960    public void removeJMVListener(JMapViewerEventListener listener) {
     961        listenerList.remove(JMapViewerEventListener.class, listener);
     962    }
     963
     964    /**
     965     * Send an update to all objects registered with viewer
     966     *
     967     * @param event to dispatch
     968     */
     969    void fireJMVEvent(JMVCommandEvent evt) {
     970        Object[] listeners = listenerList.getListenerList();
     971        for (int i=0; i<listeners.length; i+=2) {
     972            if (listeners[i]==JMapViewerEventListener.class) {
     973                ((JMapViewerEventListener)listeners[i+1]).processCommand(evt);
     974            }
     975        }
     976    }
    901977}

  • Demo.java

     
    1616import javax.swing.JLabel;
    1717import javax.swing.JPanel;
    1818
     19import org.openstreetmap.gui.jmapviewer.events.JMVCommandEvent;
     20import org.openstreetmap.gui.jmapviewer.interfaces.JMapViewerEventListener;
    1921import org.openstreetmap.gui.jmapviewer.interfaces.TileLoader;
    2022import org.openstreetmap.gui.jmapviewer.interfaces.TileSource;
    2123import org.openstreetmap.gui.jmapviewer.tilesources.BingAerialTileSource;
    … …  
    2830 * @author Jan Peter Stotz
    2931 *
    3032 */
    31 public class Demo extends JFrame {
     33public class Demo extends JFrame implements JMapViewerEventListener  {
    3234
    3335    private static final long serialVersionUID = 1L;
    3436
     37    private JMapViewer map = null;
     38
     39    private JLabel zoomLabel=null;
     40    private JLabel zoomValue=null;
     41
     42    private JLabel mperpLabelName=null;
     43    private JLabel mperpLabelValue = null;
     44
    3545    public Demo() {
    3646        super("JMapViewer Demo");
    3747        setSize(400, 400);
    38         final JMapViewer map = new JMapViewer();
     48
     49        map = new JMapViewer();
     50
     51        // Listen to the map viewer for user operations so components will
     52        // recieve events and update
     53        map.addJMVListener(this);
     54
    3955        // final JMapViewer map = new JMapViewer(new MemoryTileCache(),4);
    4056        // map.setTileLoader(new OsmFileCacheTileLoader(map));
    4157        // new DefaultMapController(map);
     58
    4259        setLayout(new BorderLayout());
    4360        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    4461        setExtendedState(JFrame.MAXIMIZED_BOTH);
    4562        JPanel panel = new JPanel();
    4663        JPanel helpPanel = new JPanel();
     64
     65        mperpLabelName=new JLabel("Meters/Pixels: ");
     66        mperpLabelValue=new JLabel(String.format("%s",map.getMeterPerPixel()));
     67
     68        zoomLabel=new JLabel("Zoom: ");
     69        zoomValue=new JLabel(String.format("%s", map.getZoom()));
     70
    4771        add(panel, BorderLayout.NORTH);
    4872        add(helpPanel, BorderLayout.SOUTH);
    4973        JLabel helpLabel = new JLabel("Use right mouse button to move,\n "
    … …  
    106130        });
    107131        panel.add(showZoomControls);
    108132        panel.add(button);
     133
     134        panel.add(zoomLabel);
     135        panel.add(zoomValue);
     136        panel.add(mperpLabelName);
     137        panel.add(mperpLabelValue);
     138
    109139        add(map, BorderLayout.CENTER);
    110140
    111141        //
    … …  
    129159        new Demo().setVisible(true);
    130160    }
    131161
     162    private void updateZoomParameters() {
     163        if (mperpLabelValue!=null)
     164            mperpLabelValue.setText(String.format("%s",map.getMeterPerPixel()));
     165        if (zoomValue!=null)
     166            zoomValue.setText(String.format("%s", map.getZoom()));
     167    }
     168
     169    @Override
     170    public void processCommand(JMVCommandEvent command) {
     171        if (command.getCommand().equals(JMVCommandEvent.COMMAND.ZOOM) ||
     172                command.getCommand().equals(JMVCommandEvent.COMMAND.MOVE)) {
     173            updateZoomParameters();
     174        }
     175    }
     176
    132177}

  • events/JMVCommandEvent.java

     
     1/**
     2 *
     3 */
     4package org.openstreetmap.gui.jmapviewer.events;
     5
     6import java.util.EventObject;
     7
     8/**
     9 * Used for passing events between UI components and other
     10 * objects that register as a JMapViewerEventListener
     11 *
     12 * @author Jason Huntley
     13 *
     14 */
     15public class JMVCommandEvent extends EventObject {
     16    public static enum COMMAND {
     17        MOVE,
     18        ZOOM
     19    }
     20
     21    private COMMAND command;
     22    /**
     23     *
     24     */
     25    private static final long serialVersionUID = 8701544867914969620L;
     26
     27    public JMVCommandEvent(COMMAND cmd, Object source) {
     28        super(source);
     29
     30        setCommand(cmd);
     31    }
     32
     33    public JMVCommandEvent(Object source) {
     34        super(source);
     35    }
     36
     37    /**
     38     * @return the command
     39     */
     40    public COMMAND getCommand() {
     41        return command;
     42    }
     43
     44    /**
     45     * @param command the command to set
     46     */
     47    public void setCommand(COMMAND command) {
     48        this.command = command;
     49    }
     50}

  • interfaces/JMapViewerEventListener.java 

    Property changes on: events\JMVCommandEvent.java
___________________________________________________________________
Added: svn:eol-style
   + native
     
     1/**
     2 *
     3 */
     4package org.openstreetmap.gui.jmapviewer.interfaces;
     5
     6import java.util.EventListener;
     7
     8import org.openstreetmap.gui.jmapviewer.events.JMVCommandEvent;
     9
     10/**
     11 * Must be implemented for processing commands while user
     12 * interacts with map viewer.
     13 *
     14 * @author Jason Huntley
     15 *
     16 */
     17public interface JMapViewerEventListener extends EventListener {
     18        public void processCommand(JMVCommandEvent command);
     19}