Wie bekomme ich Längen- und Breitengrade von Google Maps x y und Zoom-Parameter

Question

Ich habe einige Fragen mit ähnlichen Titeln gesehen, aber sie scheinen sich auf x und y Pixel-Koordinaten zu beziehen.

ich über die aktuellen Fliesen Zahlen von x und y von Google Maps getTile() Funktion bin zu fragen:

Um die Frage zu klären ...

In Anbetracht der x-, y- und Zoom-Parameter in den getTile () Funktion, wie finde ich die Breiten- und Längengrenzen der Kachel?

Der einzige Grund in dem Moment, den ich brauche, ist, dass ich die maximale Zoomstufe bei dieser Kachelprojektion bestimmen möchte. Von diesem Link: Maximum Zoom, es besagt, dass, um den maximalen Zoom zu finden, ich einen Breiten- und Längengradwert mit getMaxZoomAtLatLng() benötigen. Wenn ich also die Grenzen erreichen kann, kann ich jeden beliebigen Längen- und Breitengrad innerhalb der Grenzen verwenden, um meinen maximalen Zoom zu finden.

Alternativen, an die ich gedacht habe, waren ein Image zu erstellen und zu prüfen, ob die src URL einen Fehler hatte (das scheint mir eine schreckliche Idee zu sein, da ich viele schlechte Anfragen machen würde, nur um zu überprüfen, ob Bilder existieren).

var img = new Image; 
img.onload = function() {/*imagery exists*/ } 
img.onerror = function() {/*past maximum zoom*/ } 
img.src = url; 

EDIT:

Nach einer weiteren Untersuchung stelle ich fest, dass die getMaxZoomAtLatLng() Funktion einen Ajax-Aufruf verwendet, die in meine Pläne passen nicht. Aber ich bin immer noch daran interessiert, wie man die Breiten- und Längengrenzen einer gegebenen Kachel findet (was für andere Anwendungen nützlich sein könnte).

Answer 1

eine grundlegende Google-Karte unter Verwendung von Mercator-Projektion und eine tileSize von 256x256 Angenommen:

die Anzahl der Kacheln an jeder (x-Achse und y-Achse) ist Math.pow(2,zoom), usw. Zoom 0 die Karte verwendet, ist 1 Fliese, auf Zoom 1 4 Fliesen, auf Zoom 2 16 Fliesen und so weiter.

Zuerst die Südwest-/Nordostpunkte der Fliese berechnen.

die Größe einer Kachel (in Punkten) ist 256/Math.pow(2,zoom)

südwestPunkt:

x = tile.x * tileSizeInPoints 
y = (tile.y * tileSizeInPoints) + tileSizeInPoints 

Nordost-Punkt:

x = (tile.x * tileSizeInPoints) + tileSizeInPoints 
y = tile.y * tileSizeInPoints 

Diese Punkte müssen LatLngs übersetzt werden. Wenn Sie eine Karte verwenden, können Sie die Methode fromLatLngToPoint der Kartenprojektion verwenden.

Für eine benutzerdefinierte Implementierung werfen Sie einen Blick auf https://developers.google.com/maps/documentation/javascript/examples/map-coordinates.

Eine mögliche API-unabhängige Implementierung:

MERCATOR={ 

    fromLatLngToPoint:function(latLng){ 
    var siny = Math.min(Math.max(Math.sin(latLng.lat* (Math.PI/180)), 
            -.9999), 
          .9999); 
    return { 
     x: 128 + latLng.lng * (256/360), 
     y: 128 + 0.5 * Math.log((1 + siny)/(1 - siny)) * -(256/(2 * Math.PI)) 
    }; 
    }, 

    fromPointToLatLng: function(point){ 

    return { 
     lat: (2 * Math.atan(Math.exp((point.y - 128)/-(256/(2 * Math.PI)))) - 
      Math.PI/2)/ (Math.PI/180), 
     lng: (point.x - 128)/(256/360) 
    }; 

    }, 

    getTileAtLatLng:function(latLng,zoom){ 
    var t=Math.pow(2,zoom), 
     s=256/t, 
     p=this.fromLatLngToPoint(latLng); 
     return {x:Math.floor(p.x/s),y:Math.floor(p.y/s),z:zoom}; 
    }, 

    getTileBounds:function(tile){ 
    tile=this.normalizeTile(tile); 
    var t=Math.pow(2,tile.z), 
     s=256/t, 
     sw={x:tile.x*s, 
      y:(tile.y*s)+s}, 
     ne={x:tile.x*s+s, 
      y:(tile.y*s)}; 
     return{sw:this.fromPointToLatLng(sw), 
       ne:this.fromPointToLatLng(ne) 
       } 
    }, 
    normalizeTile:function(tile){ 
    var t=Math.pow(2,tile.z); 
    tile.x=((tile.x%t)+t)%t; 
    tile.y=((tile.y%t)+t)%t; 
    return tile; 
    } 

} 

Aufruf MERCATOR.getTileBounds() durch ein einzelnes Objekt als Argument mit folgendem Format liefern:

{ 
x:tileIndexX, 
y:tileIndexY, 
z:zoom 
} 

Demo: http://jsfiddle.net/doktormolle/55Nke/

Answer 2

Ich denke, Google Maps Tiling-System ist ähnlich dem Bings Maps Tiling-System. Die Kacheln beginnen oben links unten rechts und jede Kachel ist 256x256: http://msdn.microsoft.com/en-us/library/bb259689.aspx.