..e poi Google-maps "divide le acque dalle acque"

Beh, non nel senso biblico ma ..

Vorrei sapere quali opzioni ho per verificare se un punto di [Lat, Lon] è Terra o Acqua.

Google Maps ha ovviamente questi dati (i corpi d'acqua sono blu) - ma c'è qualcosa nell'API che posso usare per questo? E se no, non lo stanno servendo perché non ci hanno mai pensato? O perché è troppo complicato?

Non ho trovato alcuna informazione in merito - tranne alcune domande simili qui (come trovare il tipo di terreno o l'elevazione - ma non è esattamente ciò di cui ho bisogno).

C'è uno strato separato per questo? Un opzione? Comando? O dovrei andare a farlo manualmente?

L'unico modo in cui posso pensare a come affrontare questo (dovrei farlo manualmente) è controllare ogni tessera servita per il punto esatto e quindi controllare il valore RGB per quella tonalità della mappa di Google. Questo è solo in teoria - perché in pratica - non ho idea di come farlo, il primo ostacolo è che non so come posso convertire una posizione di pixel su una tessera in un punto [LatLon], ad esempio

Una soluzione già pronta sarebbe molto più semplice.

Nota che non ho bisogno di TUTTA l'acqua del mondo (ad esempio, non mi interessano i ruscelli, i piccoli stagni, la maggior parte dei fiumi o la piscina del tuo vicino. Ho bisogno dei punti in cui una persona può avventurarsi senza l'ausilio di un veicolo galleggiante )

EDIT I

Dopo aver letto i commenti: Il metodo di elevazione non è affidabile, ci sono troppi posti SOTTO il livello del mare (puoi vedere un elenco dei 10 "più profondi" qui http://geology.com/below-sea-level/ ) e lì ci sono troppi corpi idrici senza sbocco sul mare SOPRA il livello del mare (laghi). Il metodo di geolocalizzazione inversa non è affidabile perché restituirà un'entità geopolitica, come una città o uno stato, o ZERO molte volte. Ho già esaminato quelle pseudo-soluzioni prima di porre la domanda - ma nessuna di loro ha effettivamente risposto alla domanda - quei metodi sono, nella migliore delle ipotesi, cattivi metodi di "indovinazione".

Questi sono 2 modi diversi, puoi provare:

• Puoi utilizzare Google Maps Reverse Geocoding . Nel set di risultati è possibile determinare se si tratta di acqua controllando types. Nel caso delle acque il tipo è natural_feature. Scopri di più a questo link http://code.google.com/apis/maps/documentation/geocoding/#Types .

  Inoltre è necessario controllare i nomi delle caratteristiche, se contengono Sea, Lake, Oceane alcune altre parole relative alle acque per una maggiore precisione. Ad esempio anche i deserti sono natural_features.

  Pro : tutto il processo di rilevamento verrà eseguito sulla macchina del cliente. Non è necessario creare un proprio servizio lato server.

  Contro - Molto impreciso e le possibilità che tu non ne ottenga "nessuno" in acqua è molto alto.

• Puoi rilevare acque / terre per pixel, utilizzando Google Static Maps . Ma per questo scopo è necessario creare un servizio http.

  Questi sono i passaggi che il tuo servizio deve eseguire:

  1. Ricevere latitude, longitudee current zoomdal client.
  2. Invia http://maps.googleapis.com/maps/api/staticmap?center={latitudine ,longitudine }&zoom={zoom corrente`} & size = 1x1 & maptype = roadmap & sensor = false richieste al servizio Google Static Map.
  3. Rileva il colore del pixel dell'immagine statica 1x1.
  4. Rispondi a un'informazione sul rilevamento.

  Non è possibile rilevare il colore del pixel sul lato client. Sì, puoi caricare un'immagine statica sulla macchina del cliente e disegnare un'immagine canvassull'elemento. Ma non puoi usare getImageDatail contesto della tela per ottenere il colore del pixel. Ciò è limitato dalla politica interdominio.

  Prons : rilevamento altamente accurato

  Contro : utilizzo delle proprie risorse del server per il rilevamento

Non sembra possibile con nessun servizio Google corrente.

Ma ci sono altri servizi, come il servizio Koordinates Vector JSON Query ! Esegui semplicemente una query sui dati nell'URL e ottieni una risposta JSON / XML .

Richiesta di esempio: 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

Devi registrarti e fornire la tua chiave e il numero del layer selezionato. Puoi cercare in tutto il loro repository di layer disponibili . La maggior parte degli strati sono solo regionali, ma puoi anche trovarli globali, come World Coastline :

Quando selezioni un livello, fai clic sulla scheda "Servizi", ottieni l'URL di richiesta di esempio. Credo che devi solo registrarti e il gioco è fatto!

E ora il meglio:

Puoi caricare il tuo livello!

Non è disponibile subito, ehi devono elaborarlo in qualche modo, ma dovrebbe funzionare! Il repository dei livelli sembra effettivamente che le persone li abbiano caricati quando necessario.

Questo è quello che uso io e funziona non male ... puoi migliorare il test se hai più cpu da sprecare aggiungendo pixel.

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

Esiste un'API web gratuita che risolve esattamente questo problema chiamato onwater.io . Non è qualcosa integrato nelle mappe di Google, ma data una latitudine e una longitudine restituirà accuratamente vero o falso tramite una richiesta get.

Esempio sull'acqua: https://api.onwater.io/api/v1/results/23.92323,-66.3

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

Esempio a terra: https://api.onwater.io/api/v1/results/42.35,-71.1

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

Divulgazione completa Lavoro presso Dockwa.com , la società dietro onwater. Abbiamo costruito sull'acqua per risolvere noi stessi questo problema e aiutare la comunità. È gratuito (pagato per volumi elevati) e volevamo condividere :)

Ho pensato che fosse più interessante eseguire questa query localmente, quindi posso essere più autosufficiente: diciamo che voglio generare 25000 coordinate terrestri casuali contemporaneamente, preferirei evitare chiamate ad API esterne possibilmente costose. Ecco la mia possibilità in Python, usando l' esempio di Python menzionato da TomSchober. Fondamentalmente cerca le coordinate su un file prefabbricato da 350 MB contenente tutte le coordinate terrestri e, se le coordinate esistono lì, le stampa.

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)

Ho provato una dozzina di coordinate, funziona meravigliosamente. Il file "land_polygons.shp" può essere scaricato qui , complimenti di OpenStreetMaps. (Ho usato io stesso il primo link per il download di WGS84, forse anche il secondo funziona)

Dai un'occhiata a questo articolo . Rileva accuratamente se qualcosa è in acqua senza bisogno di un server. È un trucco che si basa sulla funzione di stile personalizzato in Google Maps.

Oltre alla geocodifica inversa - come ha sottolineato il dottor Molle , potrebbe restituire ZERO_RESULTS - puoi utilizzare il servizio Elevation. Se ottieni zero risultati con la geocodifica inversa, ottieni l'elevazione della posizione. Generalmente, il mare ottiene un numero negativo poiché il fondale è al di sotto del livello del mare. C'è un esempio completamente funzionante del servizio di elevazione.

Tieni presente che poiché Google non rende disponibili queste informazioni, nessun altro metodo è solo un'ipotesi e le ipotesi sono intrinsecamente imprecise. Tuttavia, l'utilizzo del valore typerestituito dalla geocodifica inversa o dell'elevazione se typenon è disponibile coprirà la maggior parte delle eventualità.

Questo metodo è totalmente inaffidabile. In effetti, i dati restituiti dipenderanno totalmente da quale parte del mondo stai lavorando. Ad esempio, lavoro in Francia. Se clicco sul mare sulla costa della Francia, Google restituirà la posizione LAND più vicina in cui può "indovinare". Quando ho richiesto informazioni a Google per questa stessa domanda, mi hanno risposto che non sono in grado di restituire con precisione il punto richiesto su una massa d'acqua.

Non è una risposta molto soddisfacente, lo so. Questo è abbastanza frustrante, soprattutto per quelli di noi che forniscono all'utente la possibilità di fare clic sulla mappa per definire una posizione del marker.

Se tutto il resto fallisce, puoi sempre provare a controllare l'elevazione nel punto e per una certa distanza circa - non molte cose oltre all'acqua tendono ad essere completamente piatte.

Purtroppo questa risposta non è all'interno dell'API di Google Maps e la risorsa a cui si fa riferimento non è gratuita, ma c'è un servizio web fornito da DynamicGeometry che espone un'operazione GetWaterOrLandche accetta una coppia latitudine / longitudine ( puoi vedere una demo qui ).

La mia comprensione di come questo viene implementato è utilizzando file di forma del corpo idrico. Come vengono utilizzati esattamente questi file di forma con l'API di Google Maps, ma potresti essere in grado di ottenere alcune informazioni dalla demo collegata.

Spero che questo aiuti in qualche modo.

Ecco un altro esempio in JavaScript puro: http://jsfiddle.net/eUwMf/

Come puoi vedere, l'ideia è fondamentalmente la stessa di rebe100x, ottiene l'immagine dall'API della mappa statica di Google e legge il primo 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");
    }
});

Guarda la risposta che ho dato a una domanda simile : utilizza "HIT_TEST_TERRAIN" dall'API della Terra per ottenere la funzione.

C'è un esempio funzionante dell'idea che ho messo insieme qui: http://www.msa.mmu.ac.uk/~fraser/ge/coord/

Consiglierei di rotolare il tuo qui. Puoi usare strumenti come GDAL per interrogare il contenuto sotto un punto in uno shapefile. Puoi ottenere shapefile per la geografia degli Stati Uniti da molte fonti, incluso lo US Census Bureau .

Questo può essere fatto tramite i binari GDAL, il codice sorgente C o tramite swig in Java, Python e altro.

Mappe di censimento

Informazioni GDAL

Esempio di query point in Python

Ecco una semplice soluzione

Poiché Google non fornisce risultati affidabili per quanto riguarda le coordinate che si trovano su specchi d'acqua oceanici o interni, è necessario utilizzare un altro servizio di backup, come Yandex, per fornire quelle informazioni critiche quando mancano. Molto probabilmente non vorresti utilizzare Yandex come geocodificatore principale perché Google è di gran lunga superiore nell'affidabilità e completezza dei dati del mondo, tuttavia Yandex può essere molto utile allo scopo di recuperare i dati quando si riferiscono a coordinate su corpi idrici, quindi usa entrambi.

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

I passaggi per recuperare il nome dell'oceano:

1.) Usa prima Google per invertire la geocodifica delle coordinate.

2.) Se Google restituisce zero risultati, è probabile che al 99% la coordinata si trovi su un oceano. Ora fai una richiesta di geocodifica inversa secondaria con le stesse coordinate a Yandex. Yandex restituirà una risposta JSON con per le coordinate esatte, all'interno di questa risposta ci saranno due coppie "chiave": "valore" di importanza

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

and

["GeoObject"]["name"]

Controlla la chiave del tipo, se == "idro" sai di essere su uno specchio d'acqua e poiché Google ha restituito zero risultati, è probabile che il 99,99% di questo specchio d'acqua sia un oceano. Il nome dell'oceano sarà la chiave "nome" sopra.

Ecco un esempio di come utilizzo questa strategia scritta in Ruby

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

I passaggi per recuperare il nome di uno specchio d'acqua interno:

Per questo esempio supponiamo che la nostra coordinata si trovi in ​​un lago da qualche parte:

1.) Usa prima Google per invertire la geocodifica delle coordinate.

2.) Google molto probabilmente restituirà un risultato che è un indirizzo predefinito ben visibile su un terreno vicino. In questo risultato fornisce le coordinate dell'indirizzo restituito, questa coordinata non corrisponderà a quella che hai fornito. Misura la distanza tra la coordinata che hai fornito e quella restituita con il risultato, se è significativamente diversa (ad esempio 100 iarde) quindi esegui una richiesta di backup secondaria con Yandex e controlla per vedere il valore della chiave "kind", se presente è "idro" allora sai che la coordinata giace sull'acqua. Poiché Google ha restituito un risultato rispetto all'esempio sopra, è probabile che si tratti del 99,99% di uno specchio d'acqua interno, quindi ora puoi ottenere il nome. Se "gentile" non == "idro", utilizza l'oggetto geocodificato di Google.

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

and

["GeoObject"]["name"]

Ecco lo stesso codice scritto in Ruby per ottenere inland_body_of_water

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

Una nota sulle licenze: per quanto ne so Google non consente di utilizzare i propri dati per la visualizzazione su altre mappe diverse da quelle offerte da Google. Yandex tuttavia ha licenze molto flessibili e puoi utilizzare i loro dati per essere visualizzati sulle mappe di Google.

Anche Yandex ha un limite di velocità elevato di 50.000 richieste / giorno gratuite e senza chiave API richiesta.

Sono riuscito ad avvicinarmi abbastanza utilizzando l'API di Google Elevation. Ecco un'immagine dei risultati:

Vedete che gli esagoni rimangono praticamente sulla terraferma anche se è definito un perimetro rettangolare che va in parte sull'acqua. In questo caso ho fatto un rapido controllo da Google Maps stesso e l'elevazione minima a terra era di circa 8-9m, quindi quella era la mia soglia. Il codice è per lo più copiato / incollato dalla documentazione di Google e Stack Overflow, ecco il succo completo:

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

Se l' List<Address>indirizzo restituisce 0, puoi assumere questa posizione come oceano o risorse naturali. Aggiungi semplicemente il codice sotto nel tuo metodo di risposta della risposta dell'API di Google Places.

Inizializza l'elenco sottostante come indicato

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

Essendo un principiante assoluto di Python, non sono riuscito a far funzionare la soluzione di SylvainB con lo script Python che controlla se le coordinate sono sulla terra. Sono riuscito a capirlo, tuttavia, scaricando OSGeo4W ( https://trac.osgeo.org/osgeo4w/ ) e quindi ho installato tutto ciò di cui avevo bisogno pip, Ipython e ho controllato che tutte le importazioni specificate fossero lì. Ho salvato il codice seguente come file .py.

Codice per verificare se le coordinate sono a terra

###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

Ho provato a farlo funzionare in R ma ho avuto un incubo cercando di ottenere tutti i pacchetti di cui hai bisogno per installare così bloccato su Python.

Ho una soluzione diversa qui. Nell'attuale implementazione di google map, non calcola la direzione / distanza da una posizione sull'acqua alla posizione sulla terraferma e viceversa. Perché non usiamo questa logica per determinare se il punto è terra o acqua.

Ad esempio, prendiamo questo esempio

se vogliamo determinare se un punto xè terra o acqua, allora

controlliamo la direzione tra il punto xe un punto noto yche è la terra. Se determina la direzione / distanza, il punto xè la terra oppure l'acqua.