... y luego los mapas de Google "dividen las aguas de las aguas"

Bueno, no en el sentido bíblico pero ...

Me gustaría saber qué opciones tengo para verificar si un punto de [Lat, Lon] es Tierra o Agua.

Google Maps obviamente tiene estos datos (los cuerpos de agua son azules), pero ¿hay algo en la API que pueda usar para eso? Y si no, ¿no lo están sirviendo porque nunca pensaron en ello? ¿O porque es demasiado complicado?

No he encontrado ninguna información sobre el asunto, excepto algunas preguntas similares aquí (como encontrar el tipo de terreno o elevación, pero no es exactamente lo que necesito).

¿Hay una capa separada para eso? ¿Una opción? ¿Mando? ¿O debería hacerlo manualmente?

La única forma en que puedo pensar en cómo abordar esto (si tuviera que hacerlo manualmente) es verificar cada mosaico servido para el punto exacto, y luego verificar el valor RGB para ese tono de mapa de Google. Esto es solo en teoría, porque en la práctica, no tengo idea de cómo lograrlo, el primer obstáculo es que no sé cómo puedo convertir la ubicación de un píxel en un mosaico en un punto [LatLon], por ejemplo

Una solución lista para usar sería mucho más fácil.

Tenga en cuenta que no necesito TODA el agua del mundo (por ejemplo, no me importan los arroyos, los estanques pequeños, la mayoría de los ríos o la piscina de su vecino. Necesito los puntos donde una persona puede aventurarse sin la ayuda de un vehículo flotante )

EDITAR I

Después de leer los comentarios: El método de elevación no es confiable, hay demasiados lugares DEBAJO del nivel del mar (puede ver una lista de los 10 "más profundos" aquí http://geology.com/below-sea-level/ ) y allá hay demasiados cuerpos de agua sin litoral SOBRE el nivel del mar (lagos). El método de geolocalización inversa no es confiable porque devolverá una entidad geopolítica, como ciudad o estado, o CERO muchas veces. Ya he examinado esas pseudo-soluciones antes de hacer la pregunta, pero ninguna de ellas realmente respondió la pregunta, esos métodos son, en el mejor de los casos, malos "adivinanzas".

Estas son 2 formas diferentes, puede intentar:

• Puede utilizar la codificación geográfica inversa de Google Maps . En el conjunto de resultados, puede determinar si es agua comprobando types. En caso de aguas, el tipo es natural_feature. Obtenga más información en este enlace http://code.google.com/apis/maps/documentation/geocoding/#Types .

  También debe verificar los nombres de las características, si contienen, Sea, Lake, Oceany algunas otras palabras relacionadas con las aguas para mayor precisión. Por ejemplo, los desiertos también son natural_features.

  Ventajas : todo el proceso de detección se realizará en la máquina del cliente. No es necesario crear un servicio propio del lado del servidor.

  Contras : muy inexacto y las posibilidades de que no obtenga "ninguna" en las aguas son muy altas.

• Puede detectar aguas / tierras por píxeles, utilizando Google Static Maps . Pero para este propósito necesitas crear un servicio http.

  Estos son los pasos que debe realizar su servicio:

  1. Recibir latitude, longitudey current zoomdesde el cliente.
  2. Enviar http://maps.googleapis.com/maps/api/staticmap?center={latitud ,longitud }&zoom={actual zoom`} & size = 1x1 & maptype = roadmap & sensor = solicitud falsa al servicio Google Static Map.
  3. Detecta el color de los píxeles de una imagen estática de 1x1.
  4. Responder una información sobre la detección.

  No puede detectar el color de los píxeles en el lado del cliente. Sí, puede cargar una imagen estática en la máquina del cliente y dibujar una imagen en el canvaselemento. Pero no puede utilizar getImageDatael contexto del lienzo para obtener el color de los píxeles. Esto está restringido por la política de dominio cruzado.

  Prones : detección de alta precisión

  Contras : uso de recursos propios del servidor para la detección

No parece posible con ningún servicio actual de Google.

¡Pero hay otros servicios, como el servicio Koordinates Vector JSON Query ! Simplemente consulta los datos en la URL y obtiene una respuesta JSON / XML .

Ejemplo de solicitud: 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

Debe registrarse y proporcionar su clave y el número de capa seleccionada. Puede buscar en todo su repositorio de capas disponibles . La mayoría de las capas son solo regionales, pero también puede encontrar globales, como World Coastline :

Cuando selecciona una capa, hace clic en la pestaña "Servicios" y obtiene la URL de solicitud de ejemplo. ¡Creo que solo necesitas registrarte y listo!

Y ahora lo mejor:

¡Puedes subir tu capa!

No está disponible de inmediato, tienen que procesarlo de alguna manera, ¡pero debería funcionar! El repositorio de capas en realidad parece que las personas los subieron cuando lo necesitaban.

Esto es lo que yo uso y no está funcionando tan mal ... puedes mejorar la prueba si tienes más cpu para desperdiciar agregando píxeles.

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

Existe una API web gratuita que resuelve exactamente este problema llamada onwater.io . No es algo integrado en los mapas de Google, pero dada una latitud y longitud, devolverá con precisión verdadero o falso a través de una solicitud de obtención.

Ejemplo sobre el agua: https://api.onwater.io/api/v1/results/23.92323,-66.3

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

Ejemplo en tierra: https://api.onwater.io/api/v1/results/42.35,-71.1

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

Divulgación completa Trabajo en Dockwa.com , la empresa detrás de onwater. Construimos sobre el agua para resolver este problema nosotros mismos y ayudar a la comunidad. Es de uso gratuito (pagado por un gran volumen) y queríamos compartir :)

Pensé que era más interesante hacer esta consulta localmente, por lo que puedo ser más autosuficiente: digamos que quiero generar 25000 coordenadas terrestres aleatorias a la vez, prefiero evitar llamadas a API externas posiblemente costosas. Aquí está mi oportunidad de esto en Python, usando el ejemplo de Python mencionado por TomSchober. Básicamente, busca las coordenadas en un archivo prefabricado de 350 MB que contiene todas las coordenadas terrestres y, si las coordenadas existen allí, las 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)

Probé una docena de coordenadas, funciona de maravilla. El archivo "land_polygons.shp" se puede descargar aquí , cortesía de OpenStreetMaps. (Yo mismo utilicé el primer enlace de descarga WGS84, tal vez el segundo también funcione)

Consulte este artículo . Detecta con precisión si hay algo en el agua sin necesidad de un servidor. Es un truco que se basa en la función de estilo personalizado de Google Maps.

Además de la codificación geográfica inversa, como ha señalado el Dr. Molle , puede devolver ZERO_RESULTS, puede utilizar el servicio Elevation. Si obtiene cero resultados mediante la codificación geográfica inversa, obtenga la elevación de la ubicación. Generalmente, el mar obtiene un número negativo ya que el fondo marino está por debajo del nivel del mar. Hay un ejemplo completamente elaborado del servicio de elevación.

Tenga en cuenta que, dado que Google no hace que esta información esté disponible, cualquier otro método es solo una suposición y las suposiciones son intrínsecamente inexactas. Sin embargo, el uso de la typecodificación geográfica inversa devuelta, o la elevación si typeno está disponible, cubrirá la mayoría de las eventualidades.

Este método es totalmente poco fiable. De hecho, los datos devueltos dependerán totalmente de la parte del mundo con la que esté trabajando. Por ejemplo, trabajo en Francia. Si hago clic en el mar en la costa de Francia, Google devolverá la ubicación de TIERRA más cercana que pueda "adivinar". Cuando solicité información a Google para esta misma pregunta, respondieron que no pueden devolver con precisión el punto solicitado en una masa de agua.

No es una respuesta muy satisfactoria, lo sé. Esto es bastante frustrante, especialmente para aquellos de nosotros que le brindamos al usuario la posibilidad de hacer clic en el mapa para definir la posición de un marcador.

Si todo lo demás falla, siempre puede intentar verificar la elevación en el punto y a cierta distancia; no muchas cosas además del agua tienden a ser completamente planas.

Desafortunadamente, esta respuesta no está dentro de la API de Google Maps y el recurso al que se hace referencia no es gratuito, pero hay un servicio web proporcionado por DynamicGeometry que expone una operación GetWaterOrLandque acepta un par de latitud / longitud ( puede ver una demostración aquí ).

Mi comprensión de cómo se implementa esto es mediante el uso de archivos de formas de cuerpos de agua. Cómo se utilizan exactamente estos archivos de forma con la API de Google Maps, pero es posible que pueda obtener información de la demostración vinculada.

Espero que eso ayude de algún modo.

Aquí hay otro ejemplo en JavaScript puro: http://jsfiddle.net/eUwMf/

Como puede ver, la ideia es básicamente la misma que rebe100x, obtener la imagen de la API de mapas estáticos de Google y leer el primer píxel:

$("#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");
    }
});

Vea la respuesta que di a una pregunta similar : usa "HIT_TEST_TERRAIN" de Earth Api para lograr la función.

Hay un ejemplo funcional de la idea que armé aquí: http://www.msa.mmu.ac.uk/~fraser/ge/coord/

Recomendaría rodar el tuyo aquí. Puede utilizar herramientas como GDAL para consultar el contenido bajo un punto en un shapefile. Puede obtener shapefiles para la geografía de EE. UU. De muchas fuentes, incluida la Oficina del Censo de EE . UU .

Esto se puede hacer a través de binarios GDAL, el código fuente C o mediante swig en Java, Python y más.

Mapas del censo

Información GDAL

Ejemplo de consulta de puntos en Python

Aquí hay una solución simple

Debido a que Google no proporciona resultados confiables con respecto a las coordenadas que se encuentran en el océano o en cuerpos de agua continentales, debe usar otro servicio de respaldo, como Yandex, para ayudar a proporcionar esa información crítica cuando falta. Lo más probable es que no desee utilizar Yandex como su geocodificador principal porque Google es muy superior en la confiabilidad e integridad de los datos del mundo; sin embargo, Yandex puede ser muy útil para recuperar datos cuando se relaciona con coordenadas sobre cuerpos de agua. así que usa ambos.

Documentación de Yandex: https://api.yandex.com.tr/maps/doc/geocoder/desc/concepts/input_params.xml

Los pasos para recuperar el nombre del océano:

1.) Utilice Google primero para invertir las coordenadas geográficas.

2.) Si Google devuelve cero resultados, es 99% probable que la coordenada se encuentre sobre un océano. Ahora haga una solicitud de codificación geográfica inversa secundaria con las mismas coordenadas a Yandex. Yandex devolverá una respuesta JSON con las coordenadas exactas, dentro de esta respuesta habrá dos pares de importancia "clave": "valor"

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

and

["GeoObject"]["name"]

Marque la clave de tipo, si es == "hidro", sabe que está sobre una masa de agua, y como Google no arrojó ningún resultado, es 99,99% probable que esta masa de agua sea un océano. El nombre del océano será la clave de "nombre" anterior.

Aquí hay un ejemplo de cómo uso esta estrategia escrita en Ruby

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

Los pasos para recuperar un nombre de masa de agua interior:

Para este ejemplo, suponga que nuestra coordenada se encuentra en un lago en algún lugar:

1.) Utilice Google primero para invertir las coordenadas geográficas.

2.) Es muy probable que Google devuelva un resultado que sea una dirección predeterminada prominente en un terreno cercano. En este resultado, proporciona las coordenadas de la dirección que devolvió, esta coordenada no coincidirá con la que proporcionó. Mida la distancia entre la coordenada que proporcionó y la que devolvió con el resultado, si es significativamente diferente (por ejemplo, 100 yardas), luego realice una solicitud de respaldo secundaria con Yandex y verifique el valor de la clave "tipo", si es es "hidro", entonces sabes que la coordenada se encuentra en el agua. Debido a que Google arrojó un resultado a diferencia del ejemplo anterior, es 99,99% probable que se trate de una masa de agua interior, por lo que ahora puede obtener el nombre. Si "kind" no == "hydro", entonces use el objeto geocodificado de Google.

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

and

["GeoObject"]["name"]

Aquí está el mismo código escrito en Ruby para obtener inland_body_of_water

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

Una nota sobre las licencias: Hasta donde yo sé, Google no le permite usar sus datos para mostrarlos en otros mapas que no sean los que ofrece Google. Sin embargo, Yandex tiene una licencia muy flexible y puede utilizar sus datos para que se muestren en los mapas de Google.

Además, Yandex tiene un límite de tasa alto de 50,000 solicitudes / día sin cargo y sin clave API requerida.

Me las arreglé para acercarme bastante usando la API de elevación de Google. Aquí hay una imagen de los resultados:

Verá que los hexágonos permanecen prácticamente en tierra a pesar de que se define un perímetro rectangular que va en parte sobre el agua. En este caso, hice una comprobación rápida de Google Maps y la elevación mínima en tierra era de unos 8-9 m, por lo que ese era mi umbral. El código se copia / pega principalmente de la documentación de Google y Stack Overflow, aquí está la esencia completa:

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

Si la List<Address>dirección devuelve 0, puede asumir que esta ubicación es océano o recursos naturales. Simplemente agregue el código a continuación en su método de respuesta de la respuesta de la API de Google Places.

Inicializar la lista de abajo como se menciona

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

Como un novato completo en Python, no pude hacer que la solución de SylvainB funcionara con el script de Python que verifica si las coordenadas están en tierra. Sin embargo, logré resolverlo descargando OSGeo4W ( https://trac.osgeo.org/osgeo4w/ ) y luego instalé todo lo que necesitaba pip, Ipython, y verifiqué que todas las importaciones especificadas estaban allí. Guardé el siguiente código como un archivo .py.

Código para comprobar si las coordenadas están en tierra

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

Traté de que funcionara en R, pero tuve una pesadilla al tratar de obtener todos los paquetes que necesita instalar, tan pegados a Python.

Aquí tengo una solución diferente. En la implementación actual del mapa de Google, no calcula la dirección / distancia desde una ubicación en el agua hasta la ubicación en tierra y viceversa. ¿Por qué no usamos esta lógica para determinar si el punto es tierra o agua?

Por ejemplo, tomemos este ejemplo

si queremos determinar, si un punto xes tierra o agua, entonces

comprobemos la dirección entre el punto xy un punto conocido yque es tierra. Si determina la dirección / distancia, entonces el punto xes tierra o si no es agua.