Come ottenere i limiti di latitudine e longitudine da Google Maps x ye parametri zoom

Question

Ho visto alcune domande con titoli simili, ma sembrano riferirsi alle coordinate dei pixel x e .

sto chiedendo circa i numeri reali di piastrelle x e y da Google Maps getTile() funzione:

Per chiarire la questione ...

Date le x, y, e parametri di zoom nella GetTile (), come posso trovare i limiti di latitudine e longitudine della tessera?

CoordMapType.prototype.getTile = function(coord, zoom, ownerDocument) { 

    var x = coord.x, 
    y = coord.y, 
    url = "http://mt1.google.com/vt/lyrs=y&x="+x+"&y="+y+"&z="+zoom; 
    //other stuff 
} 

L'unica ragione per cui nel momento in cui ho bisogno di questo è che voglio per determinare il livello massimo di zoom in questa proiezione di piastrelle. Da questo collegamento: Maximum Zoom, si afferma che per trovare lo zoom massimo, avrò bisogno di un valore di latitudine e longitudine usando getMaxZoomAtLatLng(). Quindi, se riesco a ottenere i limiti, quindi posso utilizzare qualsiasi latitudine e longitudine all'interno dei limiti per trovare il mio Zoom massimo.

Alternative Ho pensato di creare un'immagine e controllare se l'URL di src avesse un errore (questa mi sembra una pessima idea, dato che farei molte cattive richieste solo per verificare se esistessero immagini).

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

EDIT:

Dopo ulteriori indagini, mi rendo conto che la funzione getMaxZoomAtLatLng() sta usando una chiamata AJAX, che non si adatta nei miei piani. Ma sono ancora interessato a come trovare i limiti di latitudine e longitudine di una determinata tessera (che potrebbe essere utile per altre applicazioni).

Answer 1

Supponendo un google-mappa base utilizzando mercator proiezione e un tileSize di 256x256:

Il numero di piastrelle su ciascun (asse xe asse y) è Math.pow(2,zoom), ecc zoom 0 mappa utilizza 1 tessera, sullo zoom 1 4 tessere, sullo zoom 2 16 tessere e così via.

Prima calcolare i punti sudest/nordest della tessera.

la dimensione di una piastrella (in punti) è 256/Math.pow(2,zoom)

sud-point:

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

NorthEast-point:

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

Questi punti devono essere tradotti in LatLngs. Quando si utilizza una mappa, è possibile utilizzare il metodo fromLatLngToPoint della proiezione delle mappe.

Per un'implementazione personalizzata dai un'occhiata a https://developers.google.com/maps/documentation/javascript/examples/map-coordinates.

Una possibile API-indipendente implementazione:

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

} 

chiamata MERCATOR.getTileBounds() fornendo un unico oggetto come argomento con il seguente formato:

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

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

Answer 2

Penso che il sistema di affiancamento di mappe di Google sia simile al sistema di piastrellatura delle mappe di Bings. Le tessere iniziano da in alto a sinistra in basso a destra e ogni riquadro è 256x256: http://msdn.microsoft.com/en-us/library/bb259689.aspx.