Éviter la limite de géocodage de Google Maps?

Je crée une carte google personnalisée avec 125 marqueurs tracés via un cms. En chargeant la carte, je reçois ce message:

Le géocode a échoué pour la raison suivante: OVER_QUERY_LIMIT

Je suis à peu près sûr que c'est la façon dont j'ai géocodé les marqueurs.

Comment puis-je éviter ces avertissements et existe-t-il un moyen plus efficace de géocoder les résultats?

UPDATE: Ceci est ma tentative de réponse de Casey, je suis en train de recevoir une page blanche pour le moment.

<script type="text/javascript"> 
(function() { 

window.onload = function() { 
 var mc;
// Creating an object literal containing the properties we want to pass to the map 
var options = { 
zoom: 10, 
center: new google.maps.LatLng(52.40, -3.61), 
mapTypeId: google.maps.MapTypeId.ROADMAP 
}; 

// Creating the map 
var map = new google.maps.Map(document.getElementById('map'), options); 

// Creating a LatLngBounds object 
var bounds = new google.maps.LatLngBounds(); 

// Creating an array that will contain the addresses 
var places = []; 

// Creating a variable that will hold the InfoWindow object 
var infowindow; 
mc = new MarkerClusterer(map);
<?php
$pages = get_pages(array('child_of' => $post->ID, 'sort_column' => 'menu_order'));
$popup_content = array();
foreach($pages as $post)
    {
    setup_postdata($post);
    $fields = get_fields(); 
    $popup_content[] = '<p>'.$fields->company_name.'</p><img src="'.$fields->company_logo.'" /><br /><br /><a href="'.get_page_link($post->ID).'">View profile</a>';
    $comma = ", ";
    $full_address = "{$fields->address_line_1}{$comma}{$fields->address_line_2}{$comma}{$fields->address_line_3}{$comma}{$fields->post_code}";
    $address[] = $full_address;
    }
wp_reset_query();
echo 'var popup_content = ' . json_encode($popup_content) . ';';
echo 'var address = ' . json_encode($address) . ';';
?>

var geocoder = new google.maps.Geocoder(); 

var markers = [];

// Adding a LatLng object for each city  
for (var i = 0; i < address.length; i++) { 
    (function(i) { 
        geocoder.geocode( {'address': address[i]}, function(results, status) {
            if (status == google.maps.GeocoderStatus.OK) {
                places[i] = results[0].geometry.location;

                // Adding the markers 
                var marker = new google.maps.Marker({position: places[i], map: map});
                markers.push(marker);
                mc.addMarker(marker);

                // Creating the event listener. It now has access to the values of i and marker as they were during its creation
                google.maps.event.addListener(marker, 'click', function() {
                    // Check to see if we already have an InfoWindow
                    if (!infowindow) {
                        infowindow = new google.maps.InfoWindow();
                    }

                    // Setting the content of the InfoWindow
                    infowindow.setContent(popup_content[i]);

                    // Tying the InfoWindow to the marker 
                    infowindow.open(map, marker);
                });

                // Extending the bounds object with each LatLng 
                bounds.extend(places[i]); 

                // Adjusting the map to new bounding box 
                map.fitBounds(bounds) 
            } else { 
            alert("Geocode was not successful for the following reason: " + status); 
            }

        });

    })(i);

} 
var markerCluster = new MarkerClusterer(map, markers); 
} 
})
(); 
</script> 

Peu importe la solution, tant que les marqueurs se chargent instantanément et que les termes et conditions ne sont pas brisés.

Comme tout le monde, je pourrais vous donner une réponse avec du code, mais je ne pense pas que quelqu'un vous ait expliqué que vous agissiez dans le mauvais sens .

Pourquoi frappez-vous cette erreur? Parce que vous appelez le géocodage à chaque fois que quelqu'un visualise votre page et que vous ne mettez pas vos résultats en cache dans la base de données!

La raison de cette limite est d'empêcher l'utilisation abusive des ressources de Google (que ce soit de gré ou de force) - c'est exactement ce que vous faites :)

Bien que le géocodage de Google soit rapide, si tout le monde l'utilisait de cette façon, ses serveurs ne fonctionneraient plus. La raison pour laquelle les tables de fusion de Google existent est de faire beaucoup de gros travaux de levage du côté serveur pour vous. Le géocodage et la mise en cache des mosaïques sont effectués sur leurs serveurs. Si vous ne souhaitez pas l'utiliser, vous devez les mettre en cache sur votre serveur.

Si, quand même, 2500 demandes par jour, c'est trop peu, vous devez regarder la licence Google Maps Premier (payante) qui vous donne 100 000 demandes de géocodage par jour pour environ 10 000 euros par an (c'est beaucoup, avec la mise en cache côté serveur, vous devriez n'atteignez pas cette limite, sauf si vous êtes un site énorme ou si vous effectuez un traitement de données volumineux). Sans la mise en cache côté serveur et l'utilisation de votre approche actuelle, vous ne pourriez faire que 800 pages vues par jour!

Une fois que vous vous rendrez compte que les autres fournisseurs facturent chaque géocode , vous comprendrez que vous devez mettre en cache les résultats dans la base de données. Avec cette approche, cela vous coûterait environ 10 cents américains par page affichée!

Votre question est la suivante: pouvez-vous contourner la limite d'accélération que Google vous a donnée? Sûr. Il suffit de faire une demande à partir de différentes adresses IP. Heck, vous pouvez proxy les appels via ips amazon élastique et aurait toujours un nouveau 2500 appels alloués. Mais bien sûr, en plus d'être illégal (vous contournez effectivement la restriction imposée par les conditions d'utilisation de Google Maps), vous feriez un bidouillage pour couvrir le défaut de conception inhérent à votre système.

Alors, quel est le bon moyen pour ce cas d'utilisation? Avant d'appeler l'api google geocode, envoyez-le à votre serveur et demandez s'il se trouve dans votre cache. Si ce n'est pas le cas, appelez le géocode, stockez-le dans votre cache et renvoyez le résultat.

Il existe d'autres approches, mais cela devrait vous aider à démarrer dans la bonne direction.

Mise à jour: d' après vos commentaires ci-dessous, vous indiquez que vous utilisez PHP. Voici donc un exemple de code expliquant comment le faire correctement (recommandation de l'équipe Google): https://developers.google.com/maps/articles/phpsqlsearch_v3.

Je pense que Sasa a raison, dans les deux cas.

En ce qui concerne l'envoi simultané de toutes vos adresses, une option consiste à envoyer les demandes à intervalles réguliers. Dans le passé, en utilisant JavaScript, j’avais choisi de retarder les demandes de 0,25 seconde (semble fonctionner!) En utilisant le

setTimeout( [FUNCTION CALL] , 250 )

méthode.

En .NET j'ai opté pour:

System.Threading.Thread.Sleep(250);

Semble travailler.

EDIT: Je ne peux pas vraiment le tester, mais cela devrait / pourrait fonctionner!

Exemple Javascript. AddressArray contient des chaînes qui sont des adresses ...

for (var i = 0; i < addressArray.length; i++0 
{

setTimeout('googleGeocodingFunction(' + addressArray[i] + ')' , 250);

}

MODIFIER:

for (var i = 0; i < address.length; i++) {
    function(i) {
        setTimeout(geocoder.geocode({ 'address': address[i] }, function(results, status) {
            if (status == google.maps.GeocoderStatus.OK) {
                places[i] = results[0].geometry.location;

                var marker = new google.maps.Marker({ position: places[i], map: map });
                markers.push(marker);
                mc.addMarker(marker);
                google.maps.event.addListener(marker, 'click', function() {
                    if (!infowindow) {
                        infowindow = new google.maps.InfoWindow();
                    }

                    // Setting the content of the InfoWindow
                    infowindow.setContent(popup_content[i]);

                    // Tying the InfoWindow to the marker 
                    infowindow.open(map, marker);
                });

                // Extending the bounds object with all coordinates 
                bounds.extend(places[i]);

                // Adjusting the map to new bounding box 
                map.fitBounds(bounds)
            } else {
                alert("Geocode was not successful for the following reason: " + status);
            }
        }), 250);// End of setTimeOut Function - 250 being a quarter of a second. 
    } 
}

On dirait que vous atteignez la limite de requêtes simultanées imposée par Google (bien que je ne puisse pas trouver de référence à la limite actuelle). Vous devrez espacer vos demandes afin de ne pas envoyer 125 demandes en même temps. Notez qu'il existe également une limite de 2 500 requêtes de géocodage par jour.

Consultez le document Google Geocoding Strategies pour plus d'informations.

Mise à jour: En tant que solution ajoutée inspirée par un message de Mapperz, vous pouvez envisager de créer une nouvelle table Google Fusion , de stocker votre adresse et toutes les données connexes dans la table, et de géocoder la table via leur interface Web. Il y a une limite au nombre de requêtes de géocodage qu'une table Fusion fera, mais la limite est assez grande. Une fois que vous avez atteint la limite, vous devrez soumettre à nouveau la demande de géocodage, et Fusion Tables reprendra à la place. Le bonus à cette approche est une énorme amélioration de la vitesse, car vous n'aurez besoin que de géocoder UNE FOIS, alors qu'avec votre solution actuelle, vous aurez besoin de géocoder sur chaque chargement, atteignant rapidement les limites quotidiennes.

Voici comment j'étouffe mes requêtes de géocodage en javascript, les adresses étant un tableau contenant chaque adresse à géocoder:

for (i=0;i<=addresses.length;i++) {
    setTimeout( function () {
            geocoder.geocode( { 'address': addresses[i]}, function(results, status) {

                if (status == google.maps.GeocoderStatus.OK) { 

                    //create and add marker to map based off geocode result
                    var marker = new google.maps.Marker({  
                        map: map,
                        title: results[0].formatted_address,
                        position: results[0].geometry.location
                    });

                 } //EDIT, was missing the closing bracket here
            });

    }, i * 1500);
}

Cela ajoute essentiellement une seconde et demie entre chaque demande de géocodage.

J'ai essayé la page maintenant et elle semble fonctionner maintenant .

Bien que je pense que l'approche du minuteur que vous utilisez actuellement soit correcte et que je sache le seul qui fonctionnera sans nécessiter un support côté serveur, je suggérerais les modifications suivantes (j'ai pris la liberté de réécrire vos fonctions de géocodage) profiter de la conservation locale .

LocalStorage est une technologie relativement nouvelle intégrée à la plupart des navigateurs qui permet à la page Web de stocker des données sur le client. Il ressemble un peu aux cookies, mais il est beaucoup plus puissant et n’est pas toujours renvoyé au serveur (contrairement aux cookies).

Mon objectif est de sauvegarder l'adresse géocodée sur le client afin que, si un utilisateur actualise la page, il ne soit pas nécessaire d'appeler à nouveau les fonctions de géocodeur de Google. L’implémentation ci-dessous est grossière (nous devrions ajouter du code pour vérifier les enregistrements obsolètes et nous avons probablement besoin d’une meilleure clé de mise en cache que celle de l’index), mais cela devrait suffire à vous aider à démarrer. J'espère que ça aide.

(function() { 

window.onload = function() { 
 var mc;
// Creating an object literal containing the properties we want to pass to the map 
var options = { 
zoom: 0, maxZoom: 0, 
center: new google.maps.LatLng(52.40, -3.61), 
mapTypeId: google.maps.MapTypeId.ROADMAP 
}; 

// Creating the map 
var map = new google.maps.Map(document.getElementById('map'), options); 

// Creating a LatLngBounds object 
var bounds = new google.maps.LatLngBounds(); 

// Creating an array that will contain the addresses 
var places = []; 

// Creating a variable that will hold the InfoWindow object 
var infowindow; 
mc = new MarkerClusterer(map);
var popup_content = [..redacted..];

var geocoder = new google.maps.Geocoder(); 

var markers = [];

// Adding a LatLng object for each city 
function geocodeAddress(i) {
     // check if localStorage is available (it is now available on most modern browsers)
     // http://html5tutorial.net/tutorials/working-with-html5-localstorage.html
     // NB: this *must* be improved to handle quota limits, age/freshness, etc
     if(localStorage && localStorage['address_'+i]) {
        places[i]=JSON.parse(localStorage['address_'+i]);
        addPlace(i);
     } else {
      geocoder.geocode( {'address': address[i]}, function(results, status) {
        if (status == google.maps.GeocoderStatus.OK) {
            places[i] = results[0].geometry.location;
            if(localStorage) {
               // cache result locally on the browser, this will help reducing the number of requests
               // to the google geocoder in case the user refreshes the page
               // remember: the more he will refresh, the more he's likely to hit the limit
               // (this is one case where refreshing or closing the browser does not work)
               localStorage['address_'+i]=JSON.stringify(results[0].geometry.location);
            }

            addPlace(i);
        } else { 
            console.log("Geocoding of address "+address[i]+" failed");
        }
    })
}

function addPlace(i) {
    // Adding the markers 
    var marker = new google.maps.Marker({position: places[i], map: map});
    markers.push(marker);
    mc.addMarker(marker);

    // Creating the event listener. It now has access to the values of i and marker as they were during its creation
    google.maps.event.addListener(marker, 'click', function() {
        // Check to see if we already have an InfoWindow
        if (!infowindow) {
            infowindow = new google.maps.InfoWindow();
        }

        // Setting the content of the InfoWindow
        infowindow.setContent(popup_content[i]);

        // Tying the InfoWindow to the marker 
        infowindow.open(map, marker);
    });

    // Extending the bounds object with each LatLng 
    bounds.extend(places[i]); 

    // Adjusting the map to new bounding box 
    map.fitBounds(bounds);
}

function geocode() {
    if (geoIndex < address.length) {
        geocodeAddress(geoIndex);
        ++geoIndex;
    }
    else {
        clearInterval(geoTimer);
    }
}
var geoIndex = 0;
var geoTimer = setInterval(geocode, 600);  // 200 milliseconds (to try out)

var markerCluster = new MarkerClusterer(map, markers); 
} 
})
(); 

en utilisant des géocodeurs geopy, je suis capable de géocoder un grand nombre d'adresses sans accroc (je ne suis pas sûr de la configuration des affiches, ou s'il peut inclure une dépendance python à son projet)

voici mon test:

from geopy import geocoders

g = geocoders.GoogleV3()  #https://geopy.readthedocs.io/en/latest/#geopy.geocoders.GoogleV3

for x in xrange(1,10000):
    print x
    a = g.geocode("AV JOAO NAVES DE AVILA " + str(x) + " UBERLANDIA MG BRASIL")
    print a

extrait de résultat

7595 (u'Av. Jo \ xe3o Naves de \ xc1vila, 7595 - Segismundo Pereira, Uberl \ xe2ndia - Minas Gerais, 38408-288, Brésil ', (-18.9388154, -48.2220562))

7596 (u'Av. Jo \ xe3o Naves de \ xc1vila, 7596 - Segismundo Pereira, Uberl \ xe2ndia - Minas Gerais, 38408-680, Brésil ', (-18.938814, -48.2217423))

7597 (u'Av. Jo \ xe3o Naves de \ xc1vila, 7597 - Segismundo Pereira, Uberl \ xe2ndia - Minas Gerais, 38408-288, Brésil ', (-18.9388128, -48.222020381))

7598 (u'Av. Jo \ xe3o Naves de \ xc1vila, 7598 - Segismundo Pereira, Uberl \ xe2ndia - Minas Gerais, 38408-680, Brésil ', (-18.9388114, -48.2217242))

7599 (u'Av. Jo \ xe3o Naves de \ xc1vila, 7599 - Segismundo Pereira, Uberl \ xe2ndia - Minas Gerais, 38408-288, Brésil ', (-18.9388102, -48.2220201))

7600 (u'Av. Jo \ xe3o Naves de \ xc1vila, 7600 - Segismundo Pereira, Uberl \ xe2ndia - Minas Gerais, 38408-680, Brésil ', (-18.9388088, -48.2217062))

Ceci est toujours en cours et je suis avec 7k résultats.

EDIT: Après un moment, j'ai frappé le bout de la rue et Google a commencé à me donner les mêmes points, mais on dirait que c'est toujours faire des demandes et me donner des réponses précises.

Cette fonction php (je ne sais pas dans quelle langue vous travaillez, mais vous pouvez la choisir séparément) utilise google geolocator api. Étant donné une adresse, il retournera l'adresse normalisée et latlong. HTH.

// GEOLOCATEBYADDRESS
// @arg (string)address
// @return (array) ((int)flag,(array)address,array(rawresponse))

function geolocatebyaddress($lookupaddress){

    $lookupaddress=trim("$lookupaddress New Zealand");
    $lookupaddress=urlencode($lookupaddress);

    //send off google api lookup request
    $apiurl="http://maps.google.com/maps/api/geocode/json";
    $apiurl.="?address=$lookupaddress";
    $apiurl.="&region=NZ";
    $apiurl.="&sensor=false";

    if (function_exists("curl_init")) {
        $ch = curl_init();
        curl_setopt($ch, CURLOPT_URL, $apiurl);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
        $json = curl_exec($ch);
        curl_close($ch);
    }
    else     $json= file_get_contents($apiurl);

    //process response
    $response= json_decode($json,true);
    $approxflag=0;
    if ($response['status']=='OK' and count($response['results'])) {

        $aa= array();
        foreach($response['results'] as $cc=>$result) {
            //set keys
            foreach(array('street_number','road','suburb','city','postcode','region','lat','long') as $t){
                $aa[$cc][$t]='';
            }
            if ($result['geometry']){
                $aa[$cc]['lat']= $result['geometry']['location']['lat'];
                $aa[$cc]['long']=$result['geometry']['location']['lng'];
         }

            if (count($result['address_components'])){
                foreach ($result['address_components'] as $acs){
                    if ($acs['types'][0]=='street_number')               $aa[$cc]['street_number']= $acs['long_name']; 
                    if ($acs['types'][0]=='route')                       $aa[$cc]['road']=      $acs['long_name']; 
                    if ($acs['types'][0]=='sublocality')                 $aa[$cc]['suburb']=   $acs['long_name']; 
                    if ($acs['types'][0]=='locality')                    $aa[$cc]['city']=    $acs['long_name']; 
                    if ($acs['types'][0]=='postal_code')                 $aa[$cc]['postcode']= $acs['long_name']; 
                    if ($acs['types'][0]=='administrative_area_level_1') $aa[$cc]['region']=   $acs['long_name']; 
                }    
            }
            //successful?
            if ($result['geometry']['location_type']=='APPROXIMATE') $approxflag++;
            if (isset($result['partial_match']))  $approxflag++;
            if (!$aa[$cc]['street_number'])         $approxflag++;
        }
        if ($approxflag) return (array(1,$aa,$response));
        else return (array(2,$aa,$response));
    }
    else return (array(0,array(),$response));
}    

Vous venez de voir votre requête. Vous pouvez essayer de suivre le code. Dans la partie vérification de l'état du géocode, appelez de manière récursive la même fonction avec un intervalle de temps pour les adresses perdues.

function spotPosition(address) {
        geocoder.geocode({ 'address': address }, function (results, status) {
            if (status == google.maps.GeocoderStatus.OK) {
                var lat = results[0].geometry.location.lat();
                var lang = results[0].geometry.location.lng();
                setMarker(lat, lang);
            }
            else if (status == google.maps.GeocoderStatus.OVER_QUERY_LIMIT) {
                setTimeout(function () {
                    //Recursively calling spotPosition method for lost addresses
                    spotPosition(address);
                }, 1000);
            }
        });
    }

Voici ma solution:

dépendances: Gmaps.js, jQuery

var Maps = function($) {
   var lost_addresses = [],
       geocode_count  = 0;

   var addMarker = function() { console.log('Marker Added!') };

   return {
     getGecodeFor: function(addresses) {
        var latlng;
        lost_addresses = [];
        for(i=0;i<addresses.length;i++) {
          GMaps.geocode({
            address: addresses[i],
            callback: function(response, status) {
              if(status == google.maps.GeocoderStatus.OK) {
                addMarker();
              } else if(status == google.maps.GeocoderStatus.OVER_QUERY_LIMIT) {
                lost_addresses.push(addresses[i]);
              }

               geocode_count++;
               // notify listeners when the geocode is done
               if(geocode_count == addresses.length) {
                 $.event.trigger({ type: 'done:geocoder' });
               }
            }
          });
        }
     },
     processLostAddresses: function() {
       if(lost_addresses.length > 0) {
         this.getGeocodeFor(lost_addresses);
       }
     }
   };
}(jQuery);

Maps.getGeocodeFor(address);

// listen to done:geocode event and process the lost addresses after 1.5s
$(document).on('done:geocode', function() {
  setTimeout(function() {
    Maps.processLostAddresses();
  }, 1500);
});

Vous ne pouvez pas éviter la limite de géocodage de Google Map: vous devez obtenir et stocker des informations LatLng .

Si vous avez plusieurs villes et que vous ne voulez pas obtenir manuellement LatLng, vous pouvez utiliser un délai pour appeler progressivement geocoder.geocode et enregistrer les informations dans un objet javascript, puis utiliser console.log(JSON.stringify(object, null, 4));pour obtenir dans la console un bel objet imprimé. Exemple

            var locationsPosition = {
                    "Johannesburg - ZA": {
                        "lat": -26.2041028,
                        "lng": 28.047305100000017
                    },
                    "Chennai - IN": {
                        "lat": 13.0826802,
                        "lng": 80.27071840000008
                    }
             }

alors maintenant vous pouvez ajouter un marqueur en utilisant locationsPosition["Johannesburg - ZA"].latet.lng

Il semble que vous deviez faire l'une des deux choses suivantes:

1. changez votre processus pour mettre en cache les résultats si vous n'en obtenez pas autant qui sont uniques par jour; ou
2. passer à un service qui vous permet de traiter plus par jour

Comme les gens l'ont mentionné à maintes reprises, mais je n'ai aucune expérience personnelle avec, il semblerait qu'une licence de Google pour 100 000 euros par jour coûte environ 10 000 euros par an.

Si vous voulez le même niveau de précision ou mieux (et ne pas avoir à payer ce prix), vous pouvez essayer notre service. Pour beaucoup moins que Google (presque un dixième du coût), vous pourriez obtenir une limite beaucoup plus élevée que 2500 (notre limite la plus basse est de 25 000 / jour).

Bien sûr, l’utilisation de notre API Paid Geocoding n’est pas la solution que je recommanderais d’être honnête à 100%, même si c’est un mauvais sens des affaires de l’admettre. Je suggérerais plutôt d’utiliser l’option 1, d’optimiser votre service en cache. Sauf si vous avez besoin de plus de 2500 géocodes UNIQUES par jour.

Disclaimer : Je travaille pour Geocode Farm (le service que je recommande).