Bildschirmkoordinaten für Breiten- und Längengrad

Question

In der Bibliothek für offene Schichten wird unten die Methode zum Konvertieren einer Bildschirmkoordinate in Breiten- und Längengrad verwendet. Ich bin nicht in der Lage, die Logik zu verstehen, die diese Methode kapselt?

 
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); 
    } 

Kann einige Hinweise liefern jemand bitte?

Answer 1

Die Funktion berechnet einen Breiten- und Längengrad für den angegebenen Punkt basierend auf der aktuellen Auflösung der Karte und dem Breiten- und Längengrad des Mittelpunkts der aktuellen Karte und der Entfernung, die der ausgewählte Punkt von der Mitte von ist die Karte.

 
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(); 

Das obige Stück Code sammelt die Informationen für die Berechnung benötigt: Der Mittelpunkt der aktuellen Kartenansicht (die es uns gebe die lat/lon auf dem Mittelpunkt), die aktuellen Map-Auflösung, und die aktuelle Kartengröße auf dem Bildschirm des Benutzers (was durch die Bildschirmgröße usw. beeinflusst werden kann).

Dann geht die Berechnung wie folgt:

 
    //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); 

Zuerst nimmt die x Co-ord (in Pixel) und die Breite der Karte (in Pixel) subtrahiert. Dies gibt uns einen neuen x-Koordinatenwert, in dem 0 das zentrale Pixel der Karte ist. delta-x sollte nun ein Pixelwert sein, der von - (Größe.w/2) bis + (Größe.w/2) reicht. Dann machen wir das gleiche für y co-ord. Also Delta-X und Delta-Y sind jetzt kartesische Koordinaten mit dem Ursprung in der Mitte der Karte.

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

Wir müssen Delta-X und Delta-y von Pixeln zu Lat/Lon konvertieren. Zuerst multiplizieren wir Delta-x und Delta-y mit der aktuellen Auflösung. Dies gibt uns die richtige Skala, aber nicht den richtigen Ursprung. Das Hinzufügen von center.lat und centre.lon erlaubt uns, das lat/lon basierend auf der aktuell angezeigten Karte zu erhalten.

Schließlich schließt der 'neue OpenLayers.LatLon' Aufruf nur die obigen Berechnungen in einem LatLon-Objekt, so dass es von der Funktion als LatLon-Objekt zurückgegeben werden kann.

edit: Wenn mit Pixeln gearbeitet wird, bedeutet eine Erhöhung von x-Koordinate normalerweise "Bewegung nach rechts", und eine Erhöhung von y-Koordinate bedeutet normalerweise "nach oben". Wenn Sie auf einer Karte den Längengrad erhöhen, bewegen Sie sich normalerweise nach rechts. Der Breitengrad steht jedoch auf dem Kopf. Wenn Sie Latitude erhöhen, "bewegen" Sie sich normalerweise auf einer Karte nach unten.

Daher arbeitet Latitude in der entgegengesetzten Richtung zum normalen y-Koordinatensystem auf einem Bildschirm. Daher wird in der endgültigen Berechnung ein Minus für center.lat verwendet, aber ein Plus für center.lon.

Answer 2

Ich habe die vorhandenen Kommentare neu angeordnet, etwas mehr hinzugefügt und etwas Leerraum hinzugefügt. Hoffentlich wirst du das klarer finden.

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

Try this:

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; 
});