def create_stop_location_detail(title, latitude, longitude, index,
route_index):
point = Point([longitude, latitude])
properties = {
"title": title,
'icon': "campsite",
'marker-color': '#6B1A74',
'marker-symbol': index,
'route_index': route_index
}
feature = Feature(geometry=point, properties=properties)
return feature
def get_points(camp_id): #update name to id after testing
"""will return a set of coordinates"""
campsite = session.query(Campsite).filter_by(campsite_id=camp_id).first()
lat = campsite.lat
lon = campsite.lon
if lon > 0:
lon = lon * -1
point = Point((lon, lat))
session.close()
return point
def addpts(pt1, pt2, wt):
lat1 = pt1['geometry']['coordinates'][1]
lat2 = pt2['geometry']['coordinates'][1]
lon1 = pt1['geometry']['coordinates'][0]
lon2 = pt2['geometry']['coordinates'][0]
newlat = (lat1 * (1 - wt)) + lat2 * wt
newlon = (lon1 * (1 - wt)) + lon2 * wt
newpt = Feature(geometry=Point((newlon, newlat)))
return newpt
def create_yost():
proto = places_data_manager.min_place_dict
place = proto.copy()
place['name'] = 'Yost Hall'
place['type'] = 'CampusBuilding'
place['geo_coordinates'] = Point((-81.608950, 41.503553))
place['senti_score'] = -3.55
place['rating_average'] = 3.9
place['rating_count'] = 21
return place
def write_geojson(file, output_file):
features = []
for i, row in file.iterrows():
if i % 50_000 == 0:
logger.info('Processed %s / %s adresses', i, len(file))
point = Point((row['EPSG:4326_lon'], row['EPSG:4326_lat']))
properties = {
key: val
for key, val in row.to_dict().items()
if not pd.isnull(val) and 'EPSG:' not in key
}
features.append(Feature(geometry=point, properties=properties))
def create_geojson_feature(point, properties={}, feature_id=None):
"""
point is a (lon, lat) tuple,
properties is a dictionary (e.g. {'country': 'Spain})
"""
gj_point = Point(point)
gj_feature = Feature(geometry=gj_point,
properties=properties,
id=feature_id)
return gj_feature
def event_to_geojson(x,y,userID,eventID,firstName,lastName,eventName,startTime,endTime,description,attendance,attending):
return Feature(geometry=Point((x,y)),\
properties={"userID":userID,\
"eventID":eventID,\
"firstName":firstName,\
"lastName":lastName,\
"eventName":eventName,\
"startTime":startTime,\
"endTime":endTime,\
"description":description,\
"attendance":attendance,\
"attending":attending})
def create_thwing():
proto = places_data_manager.min_place_dict
place = proto.copy()
place['name'] = 'Thwing Student Center'
place['type'] = 'CampusBuilding'
place['geo_coordinates'] = Point((-81.608199, 41.507386))
place['senti_score'] = 6
place['rating_average'] = 4
place['rating_count'] = 14
return place
def test_boolean_point_in_polygon():
point = Feature(geometry=Point((-77, 44)))
polygon = Feature(
geometry=MultiPolygon(
[
([(-81, 41), (-81, 47), (-72, 47), (-72, 41), (-81, 41)],),
([(3.78, 9.28), (-130.91, 1.52), (35.12, 72.234), (3.78, 9.28)],),
]
)
)
bpp = boolean_point_in_polygon(point, polygon)
assert bpp == True
def get_all_visits_user_geojson(user_id):
visits = user_traces_db.load_user_all_visits_per_place(user_id)
features = []
for v in visits:
features.append(
Feature(geometry=Point((v['lon'], v['lat'])),
properties={
"dur": v['dur'],
"nb_visits": v['nb_visits']
}))
return FeatureCollection(features)
def get_pm10_points_as_geojson(source):
pm10_data = get_pm10_data(source)
features = []
for index, measurement in enumerate(pm10_data['measurements']):
polygon = Point(
(pm10_data['longitudes'][index], pm10_data['latitudes'][index]))
features.append(
Feature(geometry=polygon, properties={"value": measurement}))
feature_collection = FeatureCollection(features)
return feature_collection
def create(self, validated_data):
plan_file_json = validated_data['plan_file_json']
plan_file = self.parse_and_validate_plan_file(
plan_file_json=plan_file_json)
all_geo_json_features = []
for mission_item in plan_file.Mission.Items:
if isinstance(mission_item, SimpleMissionItem):
if mission_item.Params[5] and mission_item.Params[4]:
p = Point([mission_item.Params[5], mission_item.Params[4]])
all_geo_json_features.append(Feature(geometry=p))
elif isinstance(mission_item, ComplexMissionItem):
if mission_item.Polygon != 0:
all_polygon_points = []
for polygon_coordinates in mission_item.Polygon:
p = Point(
[polygon_coordinates[1], polygon_coordinates[0]])
all_polygon_points.append(p)
polygon = Polygon(all_polygon_points)
all_geo_json_features.append(Feature(geometry=polygon))
if mission_item.Polyline != 0:
all_polyline_points = []
for polyline_coordinates in mission_item.Polyline:
p = Point(
[polyline_coordinates[1], polyline_coordinates[0]])
all_polyline_points.append(p)
polyline = LineString(all_polyline_points)
all_geo_json_features.append(Feature(geometry=polyline))
feature_collection = FeatureCollection(all_geo_json_features)
validated_data['geo_json'] = json.loads(
geojson.dumps(feature_collection))
return super(FlightPlanSerializer, self).create(validated_data)
def _getStreets(regions: FeatureCollection) -> MultiLineString:
"""Collect a set of Ways (from OSM) and convert them to a MultiLineString"""
overpassQueryUrl = OSMMiner._createCollectStreetsQuery(regions)
OSMMiner._lock.acquire()
#write_to_log("Rate limit %d, current queries: %d \n" % (OSMMiner._rateLimit, OSMMiner._currentQueries))
write_to_log(f'OSMMiner._OSMServerURL: {OSMMiner._OSMServerURL}')
#write_to_log(f'overpassQueryUrl: {overpassQueryUrl}')
while OSMMiner._currentQueries >= OSMMiner._rateLimit:
time.sleep(1)
OSMMiner._waitForAvailableSlots()
OSMMiner._currentQueries += 1
##DEBUG
#print("added query: %d\n" % OSMMiner._currentQueries)
OSMMiner._lock.release()
jsonString = requests.get(overpassQueryUrl).content
OSMMiner._currentQueries -= 1
##DEBUG
#print("removed query: %d\n" % OSMMiner._currentQueries)
try:
#TODO: Treat cases in which the OSM server fails
osmResult = OSMResult.fromJsonString(jsonString)
except:
write_to_log("Error while parsing overpass message. Message sample: %s" % jsonString[:100])
raise AttributeError("Invalid jsonString")
streetSegments = {}
# Data needs to be sorted before being grouped, otherwise
# the same group may appear multiple times
data = sorted(osmResult.Ways.values(), key=lambda x: x.tags.get('name'))
g = groupby(data, lambda x: x.tags.get('name'))
for streetName, group in g:
nodesList = [x.nodes for x in group]
OSMMiner._mergeWays(nodesList)
if streetName in streetSegments:
streetSegments[streetName] = streetSegments[streetName] + nodesList
else:
streetSegments[streetName] = nodesList
featuresList = []
for streetName in streetSegments:
featuresList.append(
Feature(id=streetName,
properties={'name':streetName},
geometry=MultiLineString([LineString([
Point([osmResult.Nodes[n].lon,
osmResult.Nodes[n].lat]) for n in s])
for s in streetSegments[streetName]]))
)
return FeatureCollection(featuresList, crs=OSMMiner._crs)
def writePointsFeatureCollection(self,latlons,colors,varname):
featureCollection = {'features':[]}
print latlons.shape,colors.shape
for latlon,color in zip(latlons,colors):
hexcolor = self.rgb2hex(color)
st = {"fillcolor": hexcolor, "radius":40}
#st = {"fillOpacity":0.3, "fillcolor": hexcolor, "color":hexcolor,"radius":40, "stroke":False}
pr = {"style":st}
ft = Feature(geometry=Point(latlon.tolist()), properties=pr)
featureCollection['features'].append(ft)
print>>self.outfile, "var %s = "%(varname)
geojson.dump(featureCollection,self.outfile)
def to_geojson(json_string, route):
stops = json.loads(json_string)
features = []
for stop in stops:
point = Point((stop["lng"], stop["lat"]))
feature = Feature(geometry=point,
properties={
"id": stop["stopid"],
"route": route,
"name": stop["stopname"]
})
features.append(feature)
return dumps(FeatureCollection(features))
def transform(self, values):
for value in values:
polygon = loads(value['geom'])
coordinates = polylabel(polygon['coordinates'][0])
value['geom'] = Point(coordinates,
crs={
'type': 'name',
'properties': {
'name': 'EPSG:3857'
}
})
return values
def transform(self, values):
features = []
for value in values:
type = value['other_tags'].get('seamark:type')
features.append(
Feature(geometry=Point(loads(value['geom'])),
properties={
'osm_ref': value['osm_id'] + 'n',
'type':
'minor' if type == 'light_minor' else 'major'
}))
return features
def get(self, lng, lat):
try:
lnglat = map(float, (lng, lat))
except Exception:
raise tornado.web.HTTPError(400)
sampler = TileSampler()
pixel = CoordSystem.lnglat_to_pixel(lnglat)
print 'Getting elevation at lng,lat:%s,%s %s,%s:' % (lng, lat, pixel[0], pixel[1])
value = yield sampler.sample_pixel(pixel)
lnglat = CoordSystem.pixel_to_lnglat(pixel)
self.write_geojson(Feature(geometry=Point(lnglat), properties={
"elevation":float(value)
}))
def tweetToFeature(tweet):
"""
Convert a tweet to a GeoJSON Feature
"""
point = Point(tweet['coordinates']['coordinates'])
properties = {
'text': tweet['text'],
'sentiment': tweet['polarity'],
'tokens': tweet['tokens']
}
feature = Feature(geometry=point, id=tweet['id'], properties=properties)
return feature
def vaccine_to_geojson(data):
geo = []
for k, v in data.items():
geo.append(
Feature(geometry=Point(
[float(str(v['longitude'])),
float(str(v['latitude']))]),
properties={
'name': v['name'],
'address': v['address']
}))
feature_collection = FeatureCollection(geo)
return feature_collection
def locations():
lat1 = float(request.args.get('lat1', -90))
long1 = float(request.args.get('long1', -180))
lat2 = float(request.args.get('lat2', 90))
long2 = float(request.args.get('long2', 180))
features = FeatureCollection(
[
Feature(geometry=Point((long, lat)), properties={"count": count})
for lat, long, count in pd.read_csv("data/unique.csv").values
if lat1 <= lat <= lat2 and long1 <= long <= long2
]
)
return jsonify(features)
def square(bbox: list):
"""
Takes a bounding box and calculates the minimum square bounding box that would contain
the input.
:param bbox: Bounding box extent in west, south, east, north order
:return: A square surrounding bbox
Example:
>>> from turfpy.measurement import square
>>> bbox = [-20, -20, -15, 0]
>>> square(bbox)
"""
west = bbox[0]
south = bbox[1]
east = bbox[2]
north = bbox[3]
horizontal_distance = distance(Feature(geometry=Point(bbox[0:2])),
Feature(geometry=Point((east, south))))
vertical_distance = distance(Feature(geometry=Point(bbox[0:2])),
Feature(geometry=Point((west, north))))
if horizontal_distance >= vertical_distance:
vertical_midpoint = (south + north) / 2
return [
west,
vertical_midpoint - ((east - west) / 2),
east,
vertical_midpoint + ((east - west) / 2),
]
else:
horizontal_midpoint = (west + east) / 2
return [
horizontal_midpoint - ((north - south) / 2),
south,
horizontal_midpoint + ((north - south) / 2),
north,
]
async def test_search_partner_by_coordinate_be_none_when_no_partner_found(
self, backend):
partner = partner_adega_ze_ambev()
coordinate = [0, 0]
await backend.save(partner)
point = Point(coordinate)
found_partner = await backend.search_nearest_by_coordinate(
coordinate=point)
assert found_partner is None
def to_geojson_feature(dx: DictAny, properties: Optional[DictAny]=None) -> Feature:
# More of this raw data from google should be pushed down
# this ix is perhaps an issue given that the data source isn't
# persisting UUIDs across updates.
g = dx["geometry"]["location"]
coords = g["lng"], g["lat"]
pt = Point(coords)
keys = ("formatted_address", "place_id", "plus_code")
if properties is not None:
for key in keys:
properties[key] = dx.get(key)
return Feature(geometry=pt, properties=properties)
def destination(origin: Feature,
distance,
bearing,
options: dict = {}) -> Feature:
"""
Takes a Point and calculates the location of a destination point given a distance in
degrees, radians, miles, or kilometers and bearing in degrees.
:param origin: Start point.
:param distance: distance upto which the destination is from origin.
:param bearing: Direction in which is the destination is from origin.
:param options: Option like units of distance and properties to be passed to
destination point feature, value
for units are 'mi', 'km', 'deg' and 'rad'.
:return: Feature: destination point in at the given distance and given direction.
Example:
>>> from turfpy.measurement import destination
>>> from geojson import Point, Feature
>>> origin = Feature(geometry=Point([-75.343, 39.984]))
>>> distance = 50
>>> bearing = 90
>>> options = {'units': 'mi'}
>>> destination(origin,distance,bearing,options)
"""
coordinates1 = origin["geometry"]["coordinates"]
longitude1 = radians(float(coordinates1[0]))
latitude1 = radians(float(coordinates1[1]))
bearingRad = radians(float(bearing))
if "units" in options:
radian = length_to_radians(distance, options["units"])
else:
radian = length_to_radians(distance)
latitude2 = asin((sin(latitude1) * cos(radian)) +
(cos(latitude1) * sin(radian) * cos(bearingRad)))
longitude2 = longitude1 + atan2(
sin(bearingRad) * sin(radian) * cos(latitude1),
cos(radian) - sin(latitude1) * sin(latitude2),
)
lng = degrees(longitude2)
lat = degrees(latitude2)
point = Point((lng, lat))
return Feature(
geometry=point,
properties=options["properties"] if "properties" in options else {},
)
def query_parks():
"""Return results from users' query based on search profile."""
user_id = session.get('user')
origin_input = request.args.get('origin')
time = request.args.get('time')
routing = request.args.get('routing')
playgrounds = request.args.get('playgrounds')
origin = geocode_location(origin_input)
# session['waypoints'].append(origin)
parks = Park.query.filter(~Park.name.contains('Playground')). \
join(Image).filter(Image.image_url != None)
# Create a dictionary containing parks within the bounding radius heuristic
close_parks = find_close_parks(origin, time, routing, parks)
# Create a list of GeoJSON objects for close parks
geojson_destinations = [
park.create_geojson_object(user_id) for park in close_parks.values()
]
# Convert origin coordinates to GeoJSON object
geojson_origin = Feature(geometry=Point((origin.longitude,
origin.latitude)))
routing_params = [geojson_origin] + geojson_destinations
# TODO: will add_rounting_time() take these params as two separate lists?
# Create distance matrix (routing time in seconds)
routing_times = get_routing_times(routing_params, routing)
# Create markers for the user's query results by adding routing times to each
# park's properties
all_markers = add_routing_time(geojson_destinations, routing_times)
markers = json.dumps(FeatureCollection(all_markers))
session['origin'] = [origin.longitude, origin.latitude]
session['routing'] = routing
return render_template('query.html',
origin=origin,
time=time,
routing=routing,
geojson_origin=geojson_origin,
geojson_destinations=geojson_destinations,
all_markers=all_markers,
markers=markers)
def save(self, calculator):
allPointsFeature = []
allPolygonsFeature = []
# polygon
for line_index, line in enumerate(calculator.points):
for point_index, point in enumerate(line):
name = "{}".format(point_index)
lineName = "{}".format(line_index)
polygon = []
rect = calculator.calculate_footprint_from(point)
polygon.append([(rect[0][0], rect[0][1]),
(rect[1][0], rect[1][1]),
(rect[2][0], rect[2][1]),
(rect[3][0], rect[3][1])])
feature = Feature(
geometry=Polygon(polygon),
properties={"name": "{}-{}".format(lineName, point_index)})
allPolygonsFeature.append(feature)
# points
for line_index, line in enumerate(calculator.points):
for point_index, point in enumerate(line):
name = "{}".format(point_index)
lineName = "{}".format(line_index)
#allPoints.append((line_index, point_index, point[0], point[1]))
#allPoints.append(Point(point[0], point[1]))
feature = Feature(geometry=Point((point[0], point[1])),
properties={
"name":
"{}-{}".format(lineName, point_index),
"Z": calculator.flight_height()
})
allPointsFeature.append(feature)
allFeatureCollection = FeatureCollection(
[*allPointsFeature, *allPolygonsFeature])
self._geojson = dumps(allFeatureCollection)
if self.filename != '':
try:
with open(self.filename, 'w') as file:
file.write(self._geojson)
except:
return False
return True
def test_nearest_point_on_line():
pt = Point([2.5, 1.75])
ls = Feature(geometry=LineString([(1, 2), (2, 2), (3, 2)]))
opts = {"key1": "value1", "key2": "value2"}
npl = nearest_point_on_line(ls, pt, options={"properties": opts.copy()})
assert npl.geometry["type"] == "Point"
assert npl.properties["index"] == 1
assert 27.798 == approx(npl.properties["dist"], abs=1e-3)
assert 166.682 == approx(npl.properties["location"], abs=1e-3)
assert npl.geometry.coordinates == approx([2.5, 2], abs=1e-3)
for key in opts.keys():
assert npl.properties[key] == opts[key]
def to_geojson(df, columns=None, latlon=['lat', 'lon']):
"""GEOJSON output formatting.
"""
try:
assert columns is None or isinstance(columns, string_types) or \
(isinstance(columns, Sequence) and all([isinstance(c,string_types) for c in columns]))
except:
raise IOError("Wrong format for input columns")
try:
lat, lon = latlon
assert isinstance(lat, string_types) and isinstance(
lon, string_types)
except:
raise TypeError("Wrong format for input lat/lon columns")
if isinstance(columns, string_types):
columns == [
columns,
]
if columns in (None, []):
columns = list(set(df.columns))
columns = list(
set(columns).intersection(set(df.columns)).difference(
set([lat, lon])))
# df.reindex(columns = columns) # not necessary
if _is_geojson_imported is True:
features = df.apply(lambda row: Feature(geometry=Point(
(float(row[lon]), float(row[lat])))),
axis=1).tolist()
properties = df[columns].to_dict(
'records') # columns used as properties
# properties = df.drop([lat, lon], axis=1).to_dict('records')
geom = FeatureCollection(features=features, properties=properties)
else:
geom = {'type': 'FeatureCollection', 'features': []}
for _, row in df.iterrows():
feature = {
'type': 'Feature',
'properties': {},
'geometry': {
'type': 'Point',
'coordinates': []
}
}
feature['geometry']['coordinates'] = [
float(row[lon]), float(row[lat])
]
for col in columns:
feature['properties'][col] = row[col]
geom['features'].append(feature)
return geom
def graph_to_geojson(g):
geoms = []
for node_id, node in g.node.iteritems():
geoms.append(Point([node['data'].lon, node['data'].lat]))
for from_id, to_id in g.edges_iter():
from_ = g.node[from_id]['data']
to_ = g.node[to_id]['data']
geoms.append(LineString([
(from_.lon, from_.lat),
(to_.lon, to_.lat),
]))
return GeometryCollection(geoms)
