用指定半径的圆点填充经度/纬度图的最有效方法是什么？

Question

So I'm trying to get around restrictions on a certain company's API that provides data on places of interest. The API doesn't allow me to collect results for an entire state. Instead, I must specify Lat/Lon coordinates and gather the nearby places in a circular 1 to 50000m radius. This API also only returns 60 results at a time, regardless of how many reside in the location specified. I'm aware I will encounter more than 60 places at specified locations, but I'm planning to recursively bisect and process each of these cases.

I'd like to use New York State as my first test case.

I'm using a shapefile from https://www.arcgis.com/home/item.html?id=b07a9393ecbd430795a6f6218443dccc to get the shape of NY, and shapely to determine whether my point is inside the border.

import geopandas as gpd
from shapely.geometry import Point, Polygon

usa = gpd.read_file('states_21basic/states.shp')
polygon = usa[usa.STATE_ABBR == 'NY']['geometry'].values[0]
point = Point(-74.005974,40.712776) # create point
print(polygon.contains(point)) # check if polygon contains point

It's been suggested I try a flood fill algorithm, but I'm not exactly sure how to get a list of spaced out coordinates from it (to minimize API calls) and how to ensure that every part is covered, even in weird shapes like NY.

My main goal is to collect all the places whilst minimizing API calls. I'm not really expecting any code, just an idea of how to tackle this.

**Unfortunately, I have been removed from the company and won't be able to mark answers as accepted

Answer 1

Your problem might have a good solution not a perfect solution. I worked with maps for a long time and mostly all of them are complex themselves. You have another level of complexity which is an external dependency you cannot control. I had to do something similar at a lower level querying Google Maps to obtain sites on a small area (no more than 20 meters) to try to match the closest place to where I was in terms of geolocation. First, you need to make an assumption and try it. The assumption could be to only use 100 meters radius which more or less cover one block. The second problem you have is density. You can explore a map with zero places of interest for a while (New York has a lot of open areas that might not have nearly anything around).

Let's suppose you can enclose your solution in a shape. Suggestion is you start from a predefined point in a dense area (Manhattan?) to maximize the algorithm findings at the beginning. Longer it runs, closer to detect less it will get.

The flood fill algorithm is good in your case but it might not be the best. I would probably go with something more complex that follows streets for example but a first approach using flood fill will work.

"Flood filling" is like using paint, you walk in a direction; in your case I suggest to use 8, (N, S, W, E, NW, NE, SW, SE), detect if you have "painted it" (you will need to store somewhere you've been in that position already to avoid duplicate calls, and call the API if not. Walking will open a tree of different executions, start from point A, walk N, S, E, W, NW, NE, SW, SE recursively. This recursion might be extreme in an area like New York, 100 meters each in that area will lead to several thousands level of recursion. You will require to optimize it.

The third thing to keep into consideration is checking if the point is outside of the polygon. This is pretty straightforward using PNPoly. Once you are outside the polygon, walking in that direction must stop.

I share with you the PNPoly implementation in C# I coded for a project:

public bool IsCoordinateWithinPolygon(double latitude, double longitude, Polygon polygon)
{
    if(polygon == null || polygon.Coordinates.Count() == 0)
    {
        return false;
    }

    List<double> coordinatesY = new List<double>();
    List<double> coordinatesX = new List<double>();

    var minLatitude = double.MaxValue;
    var maxLatitude = double.MinValue;
    var minLongitude = double.MaxValue;
    var maxLongitude = double.MinValue;
    // Quick-check, determine if the coordinate is outside of the bounding rectangle
    foreach(var linearRing in polygon.Coordinates)
    {
        foreach (var coordinate in linearRing.Coordinates)
        {
            coordinatesY.Add(coordinate.Latitude);
            coordinatesX.Add(coordinate.Longitude);
            if (coordinate.Latitude < minLatitude)
            {
                minLatitude = coordinate.Latitude;
            }
            if(coordinate.Latitude > maxLatitude)
            {
                maxLatitude = coordinate.Latitude;
            }
            if(coordinate.Longitude < minLongitude)
            {
                minLongitude = coordinate.Longitude;
            }
            if(coordinate.Longitude > maxLongitude)
            {
                maxLongitude = coordinate.Longitude;
            }
        }
    }

    // Determine if the coordinate is outside the bounding box
    if( (latitude < minLatitude || latitude > maxLatitude) &&
        (longitude < minLongitude || longitude < maxLongitude))
    {
        // Out of the box
        return false;
    }

    // PNPoly Algorithm - Point Inclusion in Polygon Test 
    bool inclusion = false;
    var verty = coordinatesY.ToArray();
    var vertx = coordinatesX.ToArray();
    var nvert = vertx.Length;
    var testy = latitude;
    var testx = longitude;

    for (int i = 0, j = nvert - 1; i < nvert; j = i++)
    {
        if (((verty[i] > testy) != (verty[j] > testy)) &&
         (testx < (vertx[j] - vertx[i]) * (testy - verty[i]) / (verty[j] - verty[i]) + vertx[i]))
            inclusion = !inclusion;
    }

    return inclusion;
}