Coordinate dello schermo su latitudine e longitudine

Question

Nella libreria dei livelli aperti, di seguito è riportato il metodo utilizzato per convertire le coordinate dello schermo in latitudine e longitudine. Non riesco a capire la logica che questo metodo incapsula?

getLatLonFromPoint: function (point) {
    var center = this.getCenter();
    //map center lat/lon
    var res  = this.getResolution(); 
    //pre defined by the user. Represents the change in lat long per screen unit at the given zoom level
    var size = this.getSize(); 
    //this is the width and height of the div in which the map has to be displayed
    var delta_x = point.x - (size.w / 2);
    var delta_y = point.y - (size.h / 2);
    return new OpenLayers.LatLon(
        center.lat - delta_y * res,
        center.lon + delta_x * res );
   }

Qualcuno può fornire alcuni suggerimenti?

Answer 1

La funzione calcola una latitudine e una longitudine per il punto specificato in base alla risoluzione corrente della mappa, la latitudine e la longitudine del punto centrale della mappa corrente e la distanza che il punto scelto è dal centro della mappa.

var center = this.getCenter();
//map center lat/lon
var res  = this.getResolution(); 
//pre defined by the user. Represents the change in lat long ...
var size = this.getSize(); 

Il bit di codice sopra riportato raccoglie le informazioni necessarie per il calcolo: il punto centrale della vista della mappa corrente (che ci fornirà il lat / lon sul punto centrale), la risoluzione corrente della mappa e la dimensione attuale della mappa su lo schermo degli utenti (che può essere influenzato dalle dimensioni dello schermo, ecc.).

Quindi il calcolo procede in questo modo:

    //this is the width and height of the div in which the map has to be displayed
    var delta_x = point.x - (size.w / 2);
    var delta_y = point.y - (size.h / 2);

Prima prendi il co-ord x (in pixel) e sottrai la larghezza della mappa (in pixel). Questo ci dà una nuova coordinata x in cui 0 è il pixel centrale della mappa. delta-x dovrebbe ora avere un valore in pixel compreso tra - (size.w / 2) e + (size.w / 2). Quindi facciamo lo stesso per y co-ord. Quindi delta-x e delta-y sono ora coordinate cartesiane con l'origine al centro della mappa.

    return new OpenLayers.LatLon(
        center.lat - delta_y * res,
        center.lon + delta_x * res );

Dobbiamo convertire delta-x e delta-y da pixel a lat / lon. Innanzitutto moltiplichiamo delta-x e delta-y per la risoluzione corrente. Questo ci dà la scala corretta ma non l'origine corretta. Aggiungendo centre.lat e centre.lon si adotta per darci il lat / lon in base alla mappa attualmente visualizzata.

Infine, la chiamata 'new OpenLayers.LatLon' avvolge i calcoli sopra riportati in un oggetto LatLon, in modo che possa essere restituito dalla funzione come oggetto LatLon.

modifica: quando si lavora con i pixel, un aumento di x coordinato normalmente significa "sposta a destra" e un aumento di y coordinato normalmente significa "sposta su". Su una mappa, quando si aumenta la longitudine, di solito si "sposta a destra". Tuttavia Latitude è sottosopra; quando aumenti la latitudine, normalmente ti sposti su una mappa.

Quindi Latitude lavora nella direzione opposta al normale schema di coordinate su uno schermo. Quindi nel calcolo finale viene usato un segno meno per centre.lat ma un segno più per centre.lon.

Answer 2

Ho riordinato i commenti esistenti, ne ho aggiunti altri e ho aggiunto degli spazi bianchi. Speriamo che questo sia più chiaro.

getLatLonFromPoint: function (point) {
    // point is the x and y screen coordinate

    // map center lat/lon
    var center = this.getCenter();

    // pre defined by the user. Represents the change in lat long per screen unit at the given zoom level
    var res  = this.getResolution(); 

    // this is the width and height of the screen (div) in which the map has to be displayed
    var size = this.getSize(); 

    // this is the distance of the point from the center of the screen (div)
    var delta_x = point.x - (size.w / 2);
    var delta_y = point.y - (size.h / 2);

    // return the latitude and longitude
    //   these are calculated from the center lat/lon using the 
    //   screen distances which are scaled (multiplied) by the resolution
    return new OpenLayers.LatLon(
        center.lat - delta_y * res,
        center.lon + delta_x * res );
   }

Answer 3

Prova questo:

map.events.register("mousemove", map, function(e) { 
    var position = this.events.getMousePosition(e);
    var p = map.getLonLatFromPixel(new OpenLayers.Pixel(position.x, position.y));
    // your longitude value = p.lon;
    // your latitude value = p.lat;
});