示例#1
0
def _download_parks(file_path, geofence_file, nest_parks=False):
    parks = []
    geofences = parse_geofence_file(geofence_file)

    for geofence in geofences:
        log.info('Downloading parks in geofence %s...', geofence['name'])

        box = get_geofence_box(geofence)
        parks_in_box = _query_overpass_api(box['sw'], box['ne'], nest_parks)

        coords = geofence['polygon']
        coords.append(coords[0])
        path = matplotlib.path.Path(coords)

        parks_in_geofence = []
        for park in parks_in_box:
            for coord in park:
                coord_tuple = (coord[0], coord[1])
                if path.contains_point(coord_tuple):
                    parks_in_geofence.append(park)
                    break
        log.info('%d parks found in geofence %s.', len(parks_in_geofence),
                 geofence['name'])

        parks.extend(parks_in_geofence)

    output = {"date": str(datetime.now()), "parks": parks}

    if len(output['parks']) > 0:
        with open(file_path, 'w') as file:
            json.dump(output, file, separators=(',', ':'))

        log.info('%d parks downloaded to %s.', len(output['parks']), file_path)
    else:
        log.info('0 parks downloaded. Skipping saving to %s', file_path)
示例#2
0
def flood_area(polygon):
  path = matplotlib.path.Path(polygon)

  # Calculated center.
  lat, lon = [sum(y) / len(y) for y in zip(*polygon)]
  starting_cell = s2sphere.CellId.from_lat_lng(s2sphere.LatLng.from_degrees(
      lat, lon)).parent(16)

  seen = set()
  cells = set()
  candidates = [starting_cell]

  # Add all cells that are strictly within the polygon.
  while candidates:
    cell = candidates.pop()

    if not path.contains_point(lat_lng(cell)):
      continue

    cells.add(cell)

    for neighbour in cell.get_edge_neighbors():
      if neighbour not in seen:
        seen.add(neighbour)
        candidates.append(neighbour)

  # Then add all cells on the border to make sure we cover the area.
  for cell in list(cells):
    for neighbour in cell.get_edge_neighbors():
      if neighbour not in cells:
        cells.add(neighbour)

  return cells
示例#3
0
def find_containing_building(latlon):
    """Find the building that contains item"""
    import matplotlib.path
    for building in locations:
        if building.data['type'] != 'building': continue
        path = matplotlib.path.Path(building.outline)
        if path.contains_point(latlon):
            return building
示例#4
0
def point_in_polygon(x: float, y: float,
                     polygon: typing.List[typing.List[float]]) -> bool:
    """
    Checks if a point is in a given polygon.
    :param x: x
    :param y: y
    :param polygon: The polygon to check for inclusion
    :return: Whether or not the given point is in the provided polygon
    """
    path = matplotlib.path.Path(vertices=numpy.array(polygon), closed=True)
    return path.contains_point([x, y])
示例#5
0
def count_by_position(regions, data, key=None):
    paths = {
        name: matplotlib.path.Path(
            np.array(polygon),
            ([matplotlib.path.Path.MOVETO] +
             [matplotlib.path.Path.LINETO for _ in range(len(polygon) - 2)] +
             [matplotlib.path.Path.CLOSEPOLY]
             )
        )
        for name, polygons in regions.iteritems()
        for polygon in polygons
    }
    count = collections.defaultdict(int)
    for entry in data:
        for name, path in paths.iteritems():
            pos = entry['position'][1], entry['position'][0]
            if path.contains_point(pos):
                count[name] += int(entry.get(key, 1))
    return count
def is_point_within_polygon(point, polygonVertexCoords):
     path = matplotlib.path.Path( polygonVertexCoords)
     return path.contains_point(point[0], point[1]) 
示例#7
0
def test_path():
    """Create a fake path and test it for anomalies using KDEClassifier."""

    with open("points.pickle", "r") as f:
        points = pickle.load(f)

    # all points outside of poly are ignored
    """
    poly = np.array([
            [115.707, 7.9],
            [116.509, 7.727],
            [118.295, 10.3057],
            [118.915, 13.4038],
            [118.21, 13.4038],
            [117.652, 10.667],
            [115.707, 7.9]
            ])
    """
    poly = np.array([[106.146, 4.0428], [114.046, 12.1145], [111.592, 14.1508],
                     [105.508, 4.06733], [106.146, 4.0428]])
    """
    poly = np.array([
        [113.531, 11.356],
        [113.531, 9.2452],
        [116.328, 9.2452],
        [116.328, 11.356],
        [113.531, 11.356]
    ])
    """
    raw_training_data = np.array([[
        p[0], p[1], p[3] * np.sin(p[2] / 10.0 * np.pi / 180) / 600,
        p[3] * np.cos(p[2] / 10.0 * np.pi / 180) / 600
    ] for p in points])
    path = matplotlib.path.Path(poly[:-1], closed=True)
    training_data = raw_training_data
    # crop using poly
    training_data = training_data[np.apply_along_axis(
        lambda x: False if path.contains_point([x[0], x[1]]) == 0 else True, 1,
        raw_training_data)]
    # select stationary points
    # training_data = training_data[np.where(training_data[:,2]**2+training_data[:,3]**2 < 10**-2)]
    kde = KDEClassifier(training_data)

    minx = min(training_data[:, 0])
    miny = min(training_data[:, 1])
    maxx = max(training_data[:, 0])
    maxy = max(training_data[:, 1])
    """
    start = np.array([116.103, 7.87])
    middle = np.array([117.97, 10.47])
    anom1 = np.array([117.67, 11.423])
    anom2 = np.array([119.221, 10.5673])
    anom3 = np.array([116.402, 10.8365])
    normal1 = np.array([117.786, 10.0526])
    normal2 = np.array([118.224, 11.09])
    anom4 = np.array([118.627, 9.99])
    end = np.array([118.604, 13.234])
    testing_data = np.array(create_long_path([start, normal1, anom4, normal2, end], 0.15, 0.03, 0.06))
    """

    # create a fake path
    start = np.array([106.085, 4.458])
    end = np.array([112.875, 12.623])
    normal1 = np.array([109.655, 8.7621])
    normal2 = np.array([111.436, 10.8496])
    normal3 = np.array([108.243, 7.10426])
    anom1 = np.array([108.888, 11.248])
    anom2 = np.array([108.12, 4.0956])
    anom3 = np.array([106.505, 9.48133])
    testing_data = np.array(create_long_path([end, start], 0.15, 0.03, 0.06))

    # classify!
    fixed_anom_bools = kde.classify(testing_data, fixed=True, approx=True)

    # plot results

    m = get_basemap(minx - 1, maxx + 1, miny - 1, maxy + 1)
    xpts, ypts = m(training_data[:, 0], training_data[:, 1])
    us, vs = training_data[:, 2], training_data[:, 3]
    m.scatter(xpts, ypts, c="k", marker=".", alpha=0.3)
    # m.quiver(xpts, ypts, us, vs, alpha=0.3)

    # m.plot(poly[:,0], poly[:,1])

    xs, ys = m(testing_data[:, 0], testing_data[:, 1])
    # us, vs = testing_data[:,2], testing_data[:,3]
    colors = np.where(fixed_anom_bools, "r", "g")
    m.scatter(xs, ys, c=colors, marker="8", s=100)
    # m.quiver(xs, ys, us, vs, color=colors, scale=3)

    # m.hexbin(training_data[:,0], training_data[:,1])

    plt.show()
示例#8
0
    #sys.exit(0)

    # test_path()

    points = load_points()

    print "processed file"

    poly = np.array([[91.0695, -6.4], [91.0695, -19.542], [120.211, -19.542],
                     [120.211, -6.4], [91.0695, -6.4]])
    path = matplotlib.path.Path(poly, closed=True)

    # points = points[-200000:,:2]
    points = points[np.apply_along_axis(
        lambda x: False
        if path.contains_point([x[0], x[1]]) == 0 else True, 1, points)]
    points = points[np.where(points[:, 2]**2 + points[:, 3]**2 == 0)][:, :2]
    print points.shape

    invcov = np.linalg.inv(np.cov(points.T))

    # metric = sklearn.neighbors.DistanceMetric.get_metric("mahalanobis", VI=invcov)
    def metric(x, y):
        # why is this needed
        if len(x) == 10:
            return 0
        return np.sqrt(np.einsum("i,ij,j", x - y, invcov, x - y))

    # metric = lambda foo, bar: np.sqrt((foo-bar).dot(foo-bar))
    labels = sklearn.cluster.DBSCAN(eps=0.3, metric="euclidean").fit_predict(
        points[:, :2])
示例#9
0
def test_path():
    """Create a fake path and test it for anomalies using KDEClassifier."""

    with open("points.pickle", "r") as f:
        points = pickle.load(f)

    # all points outside of poly are ignored
    """
    poly = np.array([
            [115.707, 7.9],
            [116.509, 7.727],
            [118.295, 10.3057],
            [118.915, 13.4038],
            [118.21, 13.4038],
            [117.652, 10.667],
            [115.707, 7.9]
            ])
    """
    poly = np.array([
            [106.146, 4.0428],
            [114.046, 12.1145],
            [111.592, 14.1508],
            [105.508, 4.06733],
            [106.146, 4.0428]
            ])
    """
    poly = np.array([
        [113.531, 11.356],
        [113.531, 9.2452],
        [116.328, 9.2452],
        [116.328, 11.356],
        [113.531, 11.356]
    ])
    """
    raw_training_data = np.array([[p[0], p[1], p[3]*np.sin(p[2]/10.0*np.pi/180)/600, p[3]*np.cos(p[2]/10.0*np.pi/180)/600] for p in points])
    path = matplotlib.path.Path(poly[:-1], closed=True)
    training_data = raw_training_data
    # crop using poly
    training_data = training_data[np.apply_along_axis(lambda x: False if path.contains_point([x[0], x[1]])==0 else True, 1, raw_training_data)]
    # select stationary points
    # training_data = training_data[np.where(training_data[:,2]**2+training_data[:,3]**2 < 10**-2)]
    kde = KDEClassifier(training_data)

    minx = min(training_data[:,0])
    miny = min(training_data[:,1])
    maxx = max(training_data[:,0])
    maxy = max(training_data[:,1])

    """
    start = np.array([116.103, 7.87])
    middle = np.array([117.97, 10.47])
    anom1 = np.array([117.67, 11.423])
    anom2 = np.array([119.221, 10.5673])
    anom3 = np.array([116.402, 10.8365])
    normal1 = np.array([117.786, 10.0526])
    normal2 = np.array([118.224, 11.09])
    anom4 = np.array([118.627, 9.99])
    end = np.array([118.604, 13.234])
    testing_data = np.array(create_long_path([start, normal1, anom4, normal2, end], 0.15, 0.03, 0.06))
    """

    # create a fake path
    start = np.array([106.085, 4.458])
    end = np.array([112.875, 12.623])
    normal1 = np.array([109.655, 8.7621])
    normal2 = np.array([111.436, 10.8496])
    normal3 = np.array([108.243, 7.10426])
    anom1 = np.array([108.888, 11.248])
    anom2 = np.array([108.12, 4.0956])
    anom3 = np.array([106.505, 9.48133])
    testing_data = np.array(create_long_path([end, start], 0.15, 0.03, 0.06))

    # classify!
    fixed_anom_bools = kde.classify(testing_data, fixed=True, approx=True)

    # plot results

    m = get_basemap(minx-1, maxx+1, miny-1, maxy+1)
    xpts, ypts = m(training_data[:,0], training_data[:,1])
    us, vs = training_data[:,2], training_data[:,3]
    m.scatter(xpts, ypts, c="k", marker=".", alpha=0.3)
    # m.quiver(xpts, ypts, us, vs, alpha=0.3)

    # m.plot(poly[:,0], poly[:,1])

    xs, ys = m(testing_data[:,0], testing_data[:,1])
    # us, vs = testing_data[:,2], testing_data[:,3]
    colors = np.where(fixed_anom_bools, "r", "g")
    m.scatter(xs, ys, c=colors, marker="8", s=100)
    # m.quiver(xs, ys, us, vs, color=colors, scale=3)

    # m.hexbin(training_data[:,0], training_data[:,1])

    plt.show()
示例#10
0
    points = load_points()

    print "processed file"

    poly = np.array([
        [91.0695, -6.4],
        [91.0695, -19.542],
        [120.211, -19.542],
        [120.211, -6.4],
        [91.0695, -6.4]
    ])
    path = matplotlib.path.Path(poly, closed=True)

    # points = points[-200000:,:2]
    points = points[np.apply_along_axis(lambda x: False if path.contains_point([x[0], x[1]])==0 else True, 1, points)]
    points = points[np.where(points[:,2]**2+points[:,3]**2 == 0)][:,:2]
    print points.shape

    invcov = np.linalg.inv(np.cov(points.T))
    # metric = sklearn.neighbors.DistanceMetric.get_metric("mahalanobis", VI=invcov)
    def metric(x, y):
        # why is this needed
        if len(x) == 10:
            return 0
        return np.sqrt(np.einsum("i,ij,j", x-y, invcov, x-y))
    # metric = lambda foo, bar: np.sqrt((foo-bar).dot(foo-bar))
    labels = sklearn.cluster.DBSCAN(eps=0.3, metric="euclidean").fit_predict(points[:,:2])

    print labels
    unique_labels = list(set(labels))