Coordenadas de pantalla a latitud y longitud

Question

En la biblioteca de capas abiertas, a continuación se muestra el método utilizado para convertir una coordenada de pantalla en latitud y longitud. ¿No puedo entender la lógica que encapsula este método?

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

¿Alguien puede proporcionar algunos consejos?

Answer 1

La función calcula una latitud y longitud para el punto especificado en función de la resolución actual del mapa, y la latitud y longitud del punto central del mapa actual, y la distancia que el punto elegido está desde el centro del mapa. mapa.

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

El bit de código anterior reúne la información necesaria para el cálculo: el punto central de la vista del mapa actual (que nos dará el lat / lon en el punto central), la resolución del mapa actual y el tamaño del mapa actual en la pantalla de los usuarios (que puede verse afectada por el tamaño de la pantalla, etc.).

Entonces el cálculo es así:

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

Primero tome la coordenada x (en píxeles) y reste el ancho del mapa (en píxeles). Esto nos da una nueva coordenada x en la que 0 es el píxel central del mapa. delta-x ahora debe ser un valor de píxel que varía de - (size.w / 2) a + (size.w / 2). Luego hacemos lo mismo para y co-ord. Entonces, delta-x y delta-y ahora son coordenadas cartesianas con el origen en el centro del mapa.

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

Necesitamos convertir delta-x y delta-y de píxeles a lat / lon. Primero multiplicamos delta-x y delta-y por la resolución actual. Esto nos da la escala correcta pero no el origen correcto. Agregar centre.lat y centre.lon adusts para darnos el lat / lon basado en el mapa que se muestra actualmente.

Finalmente, la llamada 'new OpenLayers.LatLon' simplemente envuelve los cálculos anteriores en un objeto LatLon, para que pueda ser devuelto desde la función como un objeto LatLon.

editar: cuando se trabaja con píxeles, un aumento en la coordenada x normalmente significa 'moverse hacia la derecha', y un aumento en la coordenada y normalmente significa 'moverse hacia arriba'. En un mapa, cuando aumenta la longitud, generalmente se 'mueve hacia la derecha'. Sin embargo, Latitude está al revés; cuando aumenta Latitud, normalmente se 'mueve hacia abajo' en un mapa.

Por lo tanto, Latitude funciona en la dirección opuesta al esquema de coordinación normal en una pantalla. Por lo tanto, en el cálculo final se usa un signo negativo para centre.lat pero un signo positivo para centre.lon.

Answer 2

Reorganicé los comentarios existentes, agregué algunos más y agregué algunos espacios en blanco. Con suerte, lo encontrarás más claro.

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

Prueba esto:

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