..et puis Google-maps "séparent les eaux des eaux"

Eh bien, pas au sens biblique mais ...

Je voudrais savoir quelles sont les options dont je dispose pour vérifier si un point de [Lat, Lon] est Terre ou Eau.

Google Maps a évidemment ces données (les plans d'eau sont bleus) - mais y a-t-il quelque chose dans l'API que je peux utiliser pour cela? Et si non - ne le servent-ils pas parce qu'ils n'y ont jamais pensé? Ou parce que c'est trop compliqué?

Je n'ai trouvé aucune information à ce sujet - à l'exception de quelques questions similaires ici (comme trouver le type de terrain ou l'élévation - mais ce n'est pas exactement ce dont j'ai besoin).

Y a-t-il une couche séparée pour cela? Une option? Commander? Ou devrais-je aller le faire manuellement?

La seule façon dont je peux penser à la façon d'aborder cela (si j'ai besoin de le faire manuellement) est de vérifier chaque tuile servie pour le point exact - puis de vérifier la valeur RVB pour cette teinte de carte Google. Ce n'est que théorique - car en pratique - je n'ai aucune idée de comment y parvenir, le premier obstacle étant que je ne sais pas comment je peux convertir un emplacement de pixel sur une tuile en point [LatLon] par exemple

Une solution toute faite serait beaucoup plus facile.

Notez que je n'ai pas besoin de TOUTE l'eau du monde (par exemple - je ne me soucie pas des ruisseaux, des petits étangs, de la plupart des rivières ou de la piscine de votre voisin. J'ai besoin des points où une personne peut s'aventurer sans l'aide d'un véhicule flottant )

EDIT I

Après lecture des commentaires: La méthode d'élévation n'est pas fiable, il y a trop d'endroits AU-DESSOUS du niveau de la mer (vous pouvez voir une liste des 10 "les plus profonds" ici http://geology.com/below-sea-level/ ) et là il y a trop de plans d'eau sans littoral AU-DESSUS du niveau de la mer (lacs). La méthode de géolocalisation inversée n'est pas fiable car elle renverra une entité géopolitique, comme une ville ou un état - ou ZERO plusieurs fois. J'ai déjà examiné ces pseudo-solutions avant de poser la question - mais aucune d'elles n'a répondu à la question - ces méthodes sont au mieux de mauvaises "devinettes".

Voici 2 façons différentes, vous pouvez essayer:

• Vous pouvez utiliser le géocodage inversé de Google Maps . Dans l'ensemble de résultats, vous pouvez déterminer s'il s'agit d'eau en vérifiant types. Dans le cas des eaux, le type est natural_feature. Pour en savoir plus, consultez ce lien http://code.google.com/apis/maps/documentation/geocoding/#Types .

  Vous devez également vérifier les noms des entités, s'ils contiennent Sea, Lake, Oceanet d'autres mots liés aux eaux pour plus de précision. Par exemple, les déserts sont également natural_features.

  Avantages - Tout le processus de détection sera effectué sur la machine du client. Pas besoin de créer son propre service côté serveur.

  Inconvénients - Très inexact et les chances que vous n'obteniez «aucune» dans les eaux sont très élevées.

• Vous pouvez détecter les eaux / terres par pixels, en utilisant Google Static Maps . Mais pour cela, vous devez créer un service http.

  Voici les étapes que votre service doit effectuer:

  1. Recevoir latitude, longitudeet current zoomdu client.
  2. Envoyer la http://maps.googleapis.com/maps/api/staticmap?center={latitude ,longitude }&zoom={zoom actuel`} & size = 1x1 & maptype = roadmap & sensor = false demande au service Google Static Map.
  3. Détecte la couleur du pixel de l'image statique 1x1.
  4. Répondez à une information sur la détection.

  Vous ne pouvez pas détecter la couleur du pixel côté client. Oui, vous pouvez charger une image statique sur la machine du client et dessiner une image sur l' canvasélément. Mais vous ne pouvez pas utiliser getImageDatale contexte du canevas pour obtenir la couleur du pixel. Ceci est limité par la politique interdomaine.

  Prons - Détection très précise

  Inconvénients - Utilisation des propres ressources du serveur pour la détection

Cela ne semble possible avec aucun service Google actuel.

Mais il existe d'autres services, comme le service Koordinates Vector JSON Query ! Vous interrogez simplement les données dans l'URL et vous récupérez une réponse JSON / XML .

Exemple de demande: http://api.koordinates.com/api/vectorQuery.json?key=YOUR_GEODATA_KEY&layer=1298&x=-159.9609375&y=13.239945499286312&max_results=3&radius=10000&geometry=true&with_field_names=true

Vous devez vous inscrire et fournir votre clé et le numéro de couche sélectionné. Vous pouvez rechercher dans tout leur référentiel de couches disponibles . La plupart des couches ne sont que régionales, mais vous pouvez également les trouver globales, comme la côte mondiale :

Lorsque vous sélectionnez une couche, vous cliquez sur l'onglet "Services", vous obtenez l'exemple d'URL de demande. Je pense qu'il vous suffit de vous inscrire et c'est tout!

Et maintenant le meilleur:

Vous pouvez télécharger votre couche!

Il n'est pas disponible tout de suite, il faut le traiter d'une manière ou d'une autre, mais ça devrait marcher! Le référentiel de couches ressemble en fait à des personnes qui les ont téléchargées selon leurs besoins.

C'est ce que j'utilise et ça marche pas trop mal ... vous pouvez améliorer le test si vous avez plus de cpu à gaspiller en ajoutant des pixels.

function isItWatter($lat,$lng) {

    $GMAPStaticUrl = "https://maps.googleapis.com/maps/api/staticmap?center=".$lat.",".$lng."&size=40x40&maptype=roadmap&sensor=false&zoom=12&key=YOURAPIKEY";  
    //echo $GMAPStaticUrl;
    $chuid = curl_init();
    curl_setopt($chuid, CURLOPT_URL, $GMAPStaticUrl);   
    curl_setopt($chuid, CURLOPT_RETURNTRANSFER, TRUE);
    curl_setopt($chuid, CURLOPT_SSL_VERIFYPEER, FALSE);
    $data = trim(curl_exec($chuid));
    curl_close($chuid);
    $image = imagecreatefromstring($data);

    // this is for debug to print the image
    ob_start();
    imagepng($image);
    $contents =  ob_get_contents();
    ob_end_clean();
    echo "<img src='data:image/png;base64,".base64_encode($contents)."' />";

    // here is the test : I only test 3 pixels ( enough to avoid rivers ... )
    $hexaColor = imagecolorat($image,0,0);
    $color_tran = imagecolorsforindex($image, $hexaColor);

    $hexaColor2 = imagecolorat($image,0,1);
    $color_tran2 = imagecolorsforindex($image, $hexaColor2);

    $hexaColor3 = imagecolorat($image,0,2);
    $color_tran3 = imagecolorsforindex($image, $hexaColor3);

    $red = $color_tran['red'] + $color_tran2['red'] + $color_tran3['red'];
    $green = $color_tran['green'] + $color_tran2['green'] + $color_tran3['green'];
    $blue = $color_tran['blue'] + $color_tran2['blue'] + $color_tran3['blue'];

    imagedestroy($image);
    var_dump($red,$green,$blue);
    //int(492) int(570) int(660) 
    if($red == 492 && $green == 570 && $blue == 660)
        return 1;
    else
        return 0;
}

Il existe une API Web gratuite qui résout exactement ce problème appelé onwater.io . Ce n'est pas quelque chose de intégré dans Google Maps, mais étant donné une latitude et une longitude, il retournera avec précision vrai ou faux via une demande d'obtention.

Exemple sur l'eau: https://api.onwater.io/api/v1/results/23.92323,-66.3

{
  lat: 23.92323,
  lon: -66.3,
  water: true
}

Exemple sur terre: https://api.onwater.io/api/v1/results/42.35,-71.1

{
  lat: 42.35,
  lon: -71.1,
  water: false
}

Divulgation complète Je travaille chez Dockwa.com , la société derrière onwater. Nous avons construit sur l'eau pour résoudre ce problème nous-mêmes et aider la communauté. Il est gratuit à utiliser (payant pour un volume élevé) et nous voulions partager :)

J'ai pensé qu'il était plus intéressant de faire cette requête localement, donc je peux être plus autonome: disons que je veux générer 25000 coordonnées de terrain aléatoires à la fois, je préfère éviter les appels à des API externes éventuellement coûteuses. Voici ma photo en python, en utilisant l' exemple python mentionné par TomSchober. Fondamentalement, il recherche les coordonnées sur un fichier prédéfini de 350 Mo contenant toutes les coordonnées terrestres, et si les coordonnées existent, il les imprime.

import ogr
from IPython import embed
import sys

drv = ogr.GetDriverByName('ESRI Shapefile') #We will load a shape file
ds_in = drv.Open("land_polygons.shp")    #Get the contents of the shape file
lyr_in = ds_in.GetLayer(0)    #Get the shape file's first layer

#Put the title of the field you are interested in here
idx_reg = lyr_in.GetLayerDefn().GetFieldIndex("P_Loc_Nm")

#If the latitude/longitude we're going to use is not in the projection
#of the shapefile, then we will get erroneous results.
#The following assumes that the latitude longitude is in WGS84
#This is identified by the number "4236", as in "EPSG:4326"
#We will create a transformation between this and the shapefile's
#project, whatever it may be
geo_ref = lyr_in.GetSpatialRef()
point_ref=ogr.osr.SpatialReference()
point_ref.ImportFromEPSG(4326)
ctran=ogr.osr.CoordinateTransformation(point_ref,geo_ref)

def check(lon, lat):
    #Transform incoming longitude/latitude to the shapefile's projection
    [lon,lat,z]=ctran.TransformPoint(lon,lat)

    #Create a point
    pt = ogr.Geometry(ogr.wkbPoint)
    pt.SetPoint_2D(0, lon, lat)

    #Set up a spatial filter such that the only features we see when we
    #loop through "lyr_in" are those which overlap the point defined above
    lyr_in.SetSpatialFilter(pt)

    #Loop through the overlapped features and display the field of interest
    for feat_in in lyr_in:
        # success!
        print lon, lat

check(-95,47)

J'ai essayé une dizaine de coordonnées, cela fonctionne à merveille. Le fichier "land_polygons.shp" peut être téléchargé ici , compliments d'OpenStreetMaps. (J'ai utilisé moi-même le premier lien de téléchargement WGS84, peut-être que le second fonctionne aussi)

Consultez cet article . Il détecte avec précision si quelque chose est sur l'eau sans avoir besoin d'un serveur. C'est un hack qui repose sur la fonctionnalité de style personnalisé de Google Maps.

En plus du géocodage inversé - comme l' a souligné le Dr Molle , il peut renvoyer ZERO_RESULTS - vous pouvez utiliser le service Elevation. Si vous n'obtenez aucun résultat par géocodage inversé, obtenez l'élévation de l'emplacement. Généralement, la mer obtient un nombre négatif car le fond marin est en dessous du niveau de la mer. Il existe un exemple complet du service d'élévation.

Gardez à l'esprit que comme Google ne rend pas ces informations disponibles, toute autre méthode n'est qu'une supposition et les suppositions sont intrinsèquement inexactes. Cependant, l'utilisation du typeretourné par géocodage inversé, ou de l'élévation si elle typen'est pas disponible, couvrira la plupart des éventualités.

Cette méthode n'est pas du tout fiable. En fait, les données renvoyées dépendront totalement de la partie du monde avec laquelle vous travaillez. Par exemple, je travaille en France. Si je clique sur la mer sur la côte de la France, Google retournera l'emplacement de TERRE le plus proche qu'il peut "deviner". Lorsque j'ai demandé des informations à Google pour cette même question, ils ont répondu qu'ils ne pouvaient pas renvoyer avec précision le point demandé sur une masse d'eau.

Pas une réponse très satisfaisante, je sais. C'est assez frustrant, en particulier pour ceux d'entre nous qui offrent à l'utilisateur la possibilité de cliquer sur la carte pour définir une position de marqueur.

Si tout le reste échoue, vous pouvez toujours essayer de vérifier l'élévation au point et sur une certaine distance environ - peu de choses autres que l'eau ont tendance à être complètement plates.

Malheureusement, cette réponse ne fait pas partie de l'API Google Maps et la ressource référencée n'est pas gratuite, mais il existe un service Web fourni par DynamicGeometry qui expose une opération GetWaterOrLandqui accepte une paire latitude / longitude ( vous pouvez voir une démo ici ).

Je comprends comment cela est mis en œuvre en utilisant des fichiers de forme de plan d'eau. Comment exactement ces fichiers de forme sont utilisés avec l'API Google Maps, mais vous pourrez peut-être obtenir un aperçu de la démo liée.

J'espère que cela contribue de quelque façon.

Voici un autre exemple en JavaScript pur: http://jsfiddle.net/eUwMf/

Comme vous pouvez le voir, l'ideia est fondamentalement le même que rebe100x, récupérant l'image de l'API de carte statique de Google et lisant le premier pixel:

$("#xGps, #yGps").change(function() {
    var img = document.getElementById('mapImg');

    // Bypass the security issue : drawing a canvas from an external URL.
    img.crossOrigin='anonymous';

    var xGps = $("#xGps").val();
    var yGps = $("#yGps").val();

    var mapUrl = "http://maps.googleapis.com/maps/api/staticmap?center=" + xGps + "," + yGps +
        "&zoom=14&size=20x20&maptype=roadmap&sensor=false";

    // mapUrl += "&key=" + key;

    $(img).attr("src", mapUrl);

    var canvas = $('<canvas/>')[0];
    canvas.width = img.width;
    canvas.height = img.height;
    canvas.getContext('2d').drawImage(img, 0, 0, img.width, img.height);

    var pixelData = canvas.getContext('2d').getImageData(1, 1, 1, 1).data;

    if (pixelData[0] == 164 &&
        pixelData[1] == 190 &&
        pixelData[2] == 220) {
        $("#result").html("Water");
    } else {
        $("#result").html("Not water");
    }
});

Voir la réponse que j'ai donnée à une question similaire - il utilise "HIT_TEST_TERRAIN" de l'API Earth pour réaliser la fonction.

Il y a un exemple concret de l'idée que j'ai mise en place ici: http://www.msa.mmu.ac.uk/~fraser/ge/coord/

Je recommanderais de rouler le vôtre ici. Vous pouvez utiliser des outils comme GDAL pour interroger le contenu sous un point dans un fichier de formes. Vous pouvez obtenir des fichiers de formes pour la géographie américaine à partir de nombreuses sources, y compris le US Census Bureau .

Cela peut être fait via les binaires GDAL, le source C ou via swig en Java, Python, etc.

Cartes de recensement

Informations GDAL

Exemple de requête de point en Python

Voici une solution simple

Étant donné que Google ne fournit pas de résultats fiables en ce qui concerne les coordonnées qui reposent sur l'océan ou les plans d'eau intérieurs, vous devez utiliser un autre service de sauvegarde, tel que Yandex, pour aider à fournir ces informations critiques lorsqu'elles sont manquantes. Vous ne voudriez probablement pas utiliser Yandex comme géocodeur principal, car Google est de loin supérieur en termes de fiabilité et d'exhaustivité des données mondiales, mais Yandex peut être très utile pour récupérer des données lorsqu'il s'agit de coordonnées sur des plans d'eau, alors utilisez les deux.

Documentation Yandex: https://api.yandex.com.tr/maps/doc/geocoder/desc/concepts/input_params.xml

Les étapes pour récupérer le nom de l'océan:

1.) Utilisez d'abord Google pour inverser le géocodage des coordonnées.

2.) Si Google ne renvoie aucun résultat, il est probable à 99% que la coordonnée se trouve au-dessus d'un océan. Faites maintenant une demande de géocodage inversé secondaire avec les mêmes coordonnées à Yandex. Yandex renverra une réponse JSON avec pour les coordonnées exactes, dans cette réponse se trouveront deux paires "clé": "valeur" d'importance

["GeoObject"]["metaDataProperty"]["GeocoderMetaData"]["kind"]

and

["GeoObject"]["name"]

Vérifiez la clé aimable, si elle == "hydro", vous savez que vous êtes au-dessus d'un plan d'eau, et comme Google n'a renvoyé aucun résultat, il est probable à 99,99% que ce plan d'eau soit un océan. Le nom de l'océan sera la clé "nom" ci-dessus.

Voici un exemple de la façon dont j'utilise cette stratégie écrite en Ruby

if result.data["GeoObject"]["metaDataProperty"]["GeocoderMetaData"]["kind"] == "hydro"
     ocean = result.data["GeoObject"]["name"] 
end

Les étapes pour récupérer un nom de plan d'eau intérieur:

Pour cet exemple, supposons que nos coordonnées se trouvent dans un lac quelque part:

1.) Utilisez d'abord Google pour inverser le géocodage des coordonnées.

2.) Google renverra très probablement un résultat qui est une adresse par défaut importante sur un terrain à proximité. Dans ce résultat, il fournit les coordonnées de l'adresse qu'il a renvoyée, cette coordonnée ne correspondra pas à celle que vous avez fournie. Mesurez la distance entre la coordonnée que vous avez fournie et celle renvoyée avec le résultat, si elle est significativement différente (par exemple 100 mètres) puis effectuez une requête de sauvegarde secondaire avec Yandex et vérifiez la valeur de la clé "kind", si elle est "hydro" alors vous savez que la coordonnée se trouve sur l'eau. Étant donné que Google a renvoyé un résultat par opposition à l'exemple ci-dessus, il est probable à 99,99% qu'il s'agisse d'une étendue d'eau intérieure, alors vous pouvez maintenant obtenir le nom. Si "kind" ne correspond pas à == "hydro", utilisez l'objet géocodé Google.

["GeoObject"]["metaDataProperty"]["GeocoderMetaData"]["kind"]

and

["GeoObject"]["name"]

Voici le même code écrit en Ruby pour obtenir inland_body_of_water

if result.data["GeoObject"]["metaDataProperty"]["GeocoderMetaData"]["kind"] == "hydro"
     inland_body_of_water = result.data["GeoObject"]["name"] 
end

Remarque sur les licences: pour autant que je sache, Google ne vous permet pas d'utiliser leurs données pour les afficher sur d'autres cartes que celles proposées par Google. Yandex dispose cependant de licences très flexibles et vous pouvez utiliser leurs données pour les afficher sur Google Maps.

Yandex a également une limite de débit élevée de 50000 demandes / jour gratuitement, et sans clé API requise.

J'ai réussi à me rapprocher en utilisant l'API Google Elevation. Voici une image des résultats:

Vous voyez que les hexagones restent à peu près sur terre même si un périmètre rectangulaire est défini qui passe en partie au-dessus de l'eau. Dans ce cas, j'ai fait une vérification rapide à partir de Google Maps lui-même et l'élévation minimale sur terre était d'environ 8 à 9 m, c'était donc mon seuil. Le code est principalement copié / collé à partir de la documentation Google et de Stack Overflow, voici l'essentiel:

https://gist.github.com/dvas0004/fd541a0502528ebfb825

Si l' List<Address>adresse renvoie 0, vous pouvez assumer cet emplacement comme océan ou ressources naturelles. Il suffit d'ajouter le code ci-dessous dans votre méthode de réponse de la réponse de l'API Google Places.

Initialiser la liste ci-dessous comme mentionné

List<Address> addresses = geocoder.getFromLocation(latLng.latitude, latLng.longitude, 1);

if (addresses.size()==0) { Toast.MakeText(getApplicationContext,"Ocean or Natural Resources selected",Toast.LENGTH_SHORT).show(); }else{ }

En tant que novice complet en Python, je n'ai pas pu faire fonctionner la solution de SylvainB avec le script python qui vérifie si les coordonnées sont sur terre. J'ai réussi à le comprendre cependant, en téléchargeant OSGeo4W ( https://trac.osgeo.org/osgeo4w/ ), puis en installant tout ce dont j'avais besoin pip, Ipython, et en vérifiant que toutes les importations spécifiées étaient là. J'ai enregistré le code suivant dans un fichier .py.

Code pour vérifier si les coordonnées sont sur terre

###make sure you check these are there and working separately before using the .py file 

import ogr
from IPython import embed
from osgeo import osr
import osgeo

import random
#####generate a 1000 random coordinates
ran1= [random.uniform(-180,180) for x in range(1,1001)]
ran2= [random.uniform(-180,180) for x in range(1,1001)]


drv = ogr.GetDriverByName('ESRI Shapefile') #We will load a shape file
ds_in = drv.Open("D:\Downloads\land-polygons-complete-4326\land-polygons-complete-4326\land_polygons.shp")    #Get the contents of the shape file
lyr_in = ds_in.GetLayer(0)    #Get the shape file's first layer

#Put the title of the field you are interested in here
idx_reg = lyr_in.GetLayerDefn().GetFieldIndex("P_Loc_Nm")

#If the latitude/longitude we're going to use is not in the projection
#of the shapefile, then we will get erroneous results.
#The following assumes that the latitude longitude is in WGS84
#This is identified by the number "4236", as in "EPSG:4326"
#We will create a transformation between this and the shapefile's
#project, whatever it may be
geo_ref = lyr_in.GetSpatialRef()
point_ref=osgeo.osr.SpatialReference()
point_ref.ImportFromEPSG(4326)
ctran=osgeo.osr.CoordinateTransformation(point_ref,geo_ref)
###check if the random coordinates are on land
def check(runs):
    lon=ran1[runs]
    lat=ran2[runs]
    #Transform incoming longitude/latitude to the shapefile's projection
    [lon,lat,z]=ctran.TransformPoint(lon,lat)
    #Create a point
    pt = ogr.Geometry(ogr.wkbPoint)
    pt.SetPoint_2D(0, lon, lat)
    #Set up a spatial filter such that the only features we see when we
    #loop through "lyr_in" are those which overlap the point defined above
    lyr_in.SetSpatialFilter(pt)
    #Loop through the overlapped features and display the field of interest
    for feat_in in lyr_in:
        return(lon, lat)

###give it a try
result = [check(x) for x in range(1,11)] ###checks first 10 coordinates

J'ai essayé de le faire fonctionner en R mais j'ai eu un cauchemar en essayant d'obtenir tous les paquets dont vous avez besoin pour installer si collé à python.

J'ai une solution différente ici. Dans la mise en œuvre actuelle de Google Map, il ne calcule pas la direction / distance entre un point d'eau et un emplacement terrestre et vice versa. Pourquoi n'utilisons-nous pas cette logique pour déterminer si le point est la terre ou l'eau?

Par exemple, prenons cet exemple

si nous voulons déterminer si un point xest la terre ou l'eau, alors

vérifions la direction entre le point xet un point connu yqui est la terre. S'il détermine la direction / distance, alors le point xest la terre ou bien c'est l'eau.