Coordonnées de l'écran en latitude et longitude

Question

Dans la bibliothèque de couches ouvertes, la méthode utilisée pour convertir une coordonnée d'écran en latitude et longitude est la suivante. Je ne suis pas capable de comprendre la logique que cette méthode encapsule?

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

Quelqu'un peut-il fournir des indications?

Answer 1

La fonction calcule une latitude et une longitude pour le point spécifié en fonction de la résolution actuelle de la carte, ainsi que la latitude et la longitude du point central de la carte actuelle et la distance entre le point choisi et le centre de la carte. carte.

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

Le bit de code ci-dessus regroupe les informations nécessaires au calcul: le point central de la vue actuelle de la carte (qui nous indiquera le lat / lon du point central), la résolution actuelle de la carte et la taille actuelle de la carte l'écran de l'utilisateur (qui peut être affecté par la taille de l'écran, etc.).

Ensuite, le calcul se déroule comme suit:

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

Prenez d’abord la coordonnée x (en pixels) et soustrayez la largeur de la carte (en pixels). Cela nous donne une nouvelle coordonnée x dans laquelle 0 est le pixel central de la carte. delta-x devrait maintenant être une valeur de pixel allant de - (size.w / 2) à + (size.w / 2). Ensuite, nous faisons la même chose pour votre coordination. Donc, delta-x et delta-y sont maintenant des coordonnées cartésiennes avec l'origine au centre de la carte.

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

Nous devons convertir delta-x et delta-y de pixels en lat / lon. On multiplie d'abord delta-x et delta-y par la résolution actuelle. Cela nous donne la bonne échelle mais pas la bonne origine. L’ajout de centre.lat et centre.lon s’ajuste pour nous donner le lat / lon basé sur la carte affichée.

Enfin, l'appel 'new OpenLayers.LatLon' enveloppe simplement les calculs ci-dessus dans un objet LatLon, de sorte qu'il puisse être renvoyé à partir de la fonction en tant qu'objet LatLon.

modifier: lorsque vous travaillez avec des pixels, une augmentation de la coordonnée x signifie normalement «déplacez-vous à droite» et une augmentation de la coordonnée y signifie normalement «déplacez-vous vers le haut». Sur une carte, lorsque vous augmentez la longitude, vous vous déplacez généralement à droite. Cependant, la latitude est à l'envers; lorsque vous augmentez la latitude, vous "descendez" normalement sur une carte.

Par conséquent, Latitude fonctionne dans le sens inverse du schéma de coordination normal sur un écran. Par conséquent, dans le calcul final, un moins est utilisé pour centre.lat mais un plus pour centre.lon.

Answer 2

J'ai réorganisé les commentaires existants, ajouté encore et ajouté des espaces. Espérons que vous le trouverez plus clair.

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

Essayez ceci:

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