Vous disposez de plusieurs coordonnées de points et vous voudriez une carte qui les affiche tous à coup sûr, tout en zoomant le plus près possible. On essayera de faire faire les calculs en priorité :

  • par le serveur (en PHP)
  • puis en Javascript
  • puis si nécessaire en faisant appel aux fonctions GoogleMaps.

Le but est de faire appel le moins possible aux fonctions de l'API, qui occasionnent un très net ralentissement.

Commencons par chercher les points extrêmes de nos données. Cela peut se faire en PHP. Il y a de nombreux moyens, en voici un :

$les_latitudes = array(); $les_longitudes = array();
foreach($tableau_de_points as $point)  {
  (...)  // afficher les marqueurs... et en profiter pour :
  $les_latitudes[]  = $point->lat; //stocker dans le tableau
  $les_longitudes[] = $point->lng;
}
$min_lat = min($les_latitudes); // plus petit du tableau
$min_lng = min($les_longitudes);
$max_lat = max($les_latitudes);
$max_lng = max($les_longitudes);

Puis nous cherchons l'étendue couverte par ces points, et le centre :

$span_lat = $max_lat - $min_lat ;
$span_lng = $max_lng - $min_lng ;
$center_lat = $min_lat + $span_lat/2 ; 
$center_lng = $min_lng _$span_lng/2 ;

En javascript, centrons la carte sur ce point au zoom maximum (le plus loin possible) :

var zoom = 5 ; // ou 1. Mettons que nous savons que 5 suffit...
map.setCenter(new GLatLng ($center_lat,$center_lng), zoom);

Tous nos marqueurs sont affichés, c'est sûr, mais on pourrait zoomer plus près... jusqu'où ? Nous allons le calculer.

Récupérons l'étendue couverte par la carte à ce niveau de zoom :

bounds = map.GetBounds();

GetBounds() retourne une paire de coordonnées GLatLng, celles des points extrêmes, par exemple :

Dans ce format, ce n'est pas très pratique. Extrayons les données pour calculer le span :

var southWest = bounds.getSouthWest();
var northEast = bounds.getNorthEast();
var lngSpan = northEast.lng() - southWest.lng();
var latSpan = northEast.lat() - southWest.lat();

Il y a peut-etre plus simple, avec une fonction idoine, mais je n'ai pas trouvé...

Là, on va se simplifier la vie par une petite astuce : comme on sait que le span (l'étendue couverte) d'une carte est divisé par deux à chaque fois que le zoom est incrémenté, on va diviser celui de notre carte jusqu'à ce que qu'il soit plus petit que le span de nos données. Alors on prendra le zoom précédent, qui sera le plus optimal. Ces calculs se font en Javascript, avec un peu de PHP pour introduire le span de nos données :

while( (spanLat > <?php echo $span_lat ?>) && (spanLng < <?php echo $span_lng ?>) && zoom < 16) {
  spanLat/=2 ;spanLng /=2; zoom++;
}

Il suffit alors de modifier le zoom :

map.setCenter(center, zoom-1);

Notre carte s'affiche de façon à montrer tous les marqueurs, le plus près possible.