def callback_flatten_each(feature, feature_index, multi_feature_index):
nonlocal length
nonlocal closest_pt
coords = get_coords(feature)
for i, coord in enumerate(coords[:-1]):
# start
start = Feature(geometry=Point(coord))
start.properties = {"dist": dist(point, start, options)}
# stop
stop = Feature(geometry=Point(coords[i + 1]))
stop.properties = {"dist": dist(point, stop, options)}
# section length
section_length = dist(start, stop, options)
# perpendicular
height_distance = max(start.properties["dist"],
stop.properties["dist"])
direction = bearing(start, stop)
perpendicular_pt1 = destination(Feature(geometry=point),
height_distance, direction + 90,
options)
perpendicular_pt2 = destination(Feature(geometry=point),
height_distance, direction - 90,
options)
intersect = line_intersect(
Feature(geometry=LineString([
get_coord(perpendicular_pt1),
get_coord(perpendicular_pt2)
])),
Feature(geometry=LineString(
[get_coord(start), get_coord(stop)])),
)
intersect_pt = None
if len(intersect["features"]) > 0:
intersect_pt = intersect["features"][0]
intersect_pt.properties["dist"] = dist(point, intersect_pt,
options)
intersect_pt.properties["location"] = length + dist(
start, intersect_pt, options)
if start.properties["dist"] < closest_pt.properties["dist"]:
closest_pt = start
closest_pt.properties["index"] = i
closest_pt.properties["location"] = length
if stop.properties["dist"] < closest_pt.properties["dist"]:
closest_pt = stop
closest_pt.properties["index"] = i + 1
closest_pt.properties["location"] = length + section_length
if (intersect_pt and intersect_pt.properties["dist"] <
closest_pt.properties["dist"]):
closest_pt = intersect_pt
closest_pt.properties["index"] = i
# update length
length += section_length
# process all Features
return True
def bbox_polygon(bbox: list, properties: dict = {}) -> Feature:
"""
To generate a Polygon Feature for the bounding box generated using bbox.
:param bbox: bounding box generated for a geojson.
:param properties: properties to be added to the returned feature.
:return: polygon for the given bounding box coordinates.
Example :
>>> from turfpy.measurement import bbox_polygon, bbox
>>> from geojson import Polygon
>>> p = Polygon([((2.38, 57.322), (23.194, -20.28), (-120.43, 19.15),
... (2.38, 57.322))])
>>> bb = bbox(p)
>>> feature = bbox_polygon(bb)
"""
west = float(bbox[0])
south = float(bbox[1])
east = float(bbox[2])
north = float(bbox[3])
if len(bbox) == 6:
raise Exception("bbox-polygon does not support BBox with 6 positions")
low_left = (west, south)
top_left = (west, north)
top_right = (east, north)
low_right = (east, south)
bbox_polygon = Polygon([(low_left, low_right, top_right, top_left,
low_left)])
feature_bbox = Feature(geometry=bbox_polygon)
if "properties" in properties:
feature_bbox.properties = properties["properties"]
elif "properties" not in properties:
feature_bbox.properties = {}
if "id" in properties:
feature_bbox.id = properties["id"]
if "bbox" in properties:
feature_bbox.bbox = properties["bbox"]
return feature_bbox
def center(geojson, properties: Optional[dict] = None) -> Feature:
"""
Takes a Feature or FeatureCollection and returns the absolute center point of all
features.
:param geojson: GeoJSON for which centered to be calculated.
:param properties: Optional parameters to be set to the generated feature.
:return: Point feature for the center.
Example :
>>> from turfpy.measurement import center
>>> from geojson import Feature, FeatureCollection, Point
>>> f1 = Feature(geometry=Point((-97.522259, 35.4691)))
>>> f2 = Feature(geometry=Point((-97.502754, 35.463455)))
>>> f3 = Feature(geometry=Point((-97.508269, 35.463245)))
>>> feature_collection = FeatureCollection([f1, f2, f3])
>>> feature = center(feature_collection)
"""
bounding_box = bbox(geojson)
x = (bounding_box[0] + bounding_box[2]) / 2
y = (bounding_box[1] + bounding_box[3]) / 2
point = Point((x, y))
center_feature = Feature(geometry=point)
if properties is None:
properties = dict()
if "properties" in properties:
center_feature.properties = properties["properties"]
elif "properties" not in properties:
center_feature.properties = {}
if "id" in properties:
center_feature.id = properties["id"]
if "bbox" in properties:
center_feature.bbox = properties["bbox"]
return center_feature
qres = g.query("""
PREFIX sdo: <http://schema.org/>
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
PREFIX dc: <http://purl.org/dc/terms/>
SELECT DISTINCT ?newsitemlabel ?label ?lon ?lat ?newsitemdate ?url
WHERE {
?item rdfs:label ?label .
?item sdo:geo ?geo .
?geo sdo:latitude ?lat .
?geo sdo:longitude ?lon .
?newsitem sdo:about ?item .
?newsitem dc:title ?newsitemlabel .
?newsitem sdo:datePublished ?newsitemdate .
?newsitem sdo:url ?url .
}""")
for row in qres:
p = Point((float(row[2].value), float(row[3].value)))
desc = f"{row[1]}: {row[4]}<br><a href='{row[5]}'>{row[0]}</a>"
f = Feature(geometry=p)
f.properties = {
"description": desc,
"name": row[1],
"time": row[4],
"url": row[5]
}
geoj.add_feature(f)
geoj.save("./data/map.json")
WHERE {
?item rdfs:label ?label .
?item sdo:geo ?geo .
?geo sdo:latitude ?lat .
?geo sdo:longitude ?lon .
?newsitem sdo:about ?item .
?newsitem dc:identifier ?post_id .
} ORDER BY ?post_id
""")
post_ids = set([row['post_id'].value for row in qres])
for post_id in post_ids:
geoj = pygeoj.new()
logger.info(f"Working on {post_id}")
for row in qres:
if int(row["post_id"].value) == int(post_id):
p = Point((float(row["lon"].value), float(row["lat"].value)))
f = Feature(geometry=p)
f.properties = {
"description": row['label'].value,
"name": row['label'].value
}
geoj.add_feature(f)
if len(geoj) > 0:
logger.info(f"Saving features for {post_id}")
geoj.save(f"./data/postmap/{post_id}.json")
else:
logger.warn(f"No features for {post_id}")
def stations_geojson_records():
db = get_database_session()
stations = get_stations(db)
records = []
for station in stations:
geom = None
if station.lat and station.lng:
geom = Point((station.lat, station.lng))
f = Feature(geometry=geom)
f.properties = {
"oid": station.oid,
"ocode": station.ocode,
"station_id": station.id,
"station_code": station.network_code,
"facility_id": station.network_code,
"network": station.network.label,
"network_country": station.network.country,
"state": station.state.upper() if station.state else None,
"postcode": station.postcode,
"name": station.name,
"capacity_registered": station.capacity_registered,
"capacity_aggregate": station.capacity_aggregate,
"duid_data": [],
}
for facility in station.facilities:
if facility.fueltech_id is None:
continue
if facility.status_id is None:
continue
if duid_is_retired(facility.code):
continue
if facility.active is False:
continue
f.properties["duid_data"].append({
"oid":
facility.oid,
"duid":
facility.duid,
"fuel_tech":
facility.fueltech_id,
"fuel_tech_label":
facility.fueltech_label,
"fuel_tech_renewable":
facility.fueltech.renewable if facility.fueltech else None,
"commissioned_date":
facility.registered,
"decommissioned_date":
facility.deregistered,
"status":
facility.status_id,
"status_label":
facility.status_label,
"unit_id":
facility.unit_id,
"unit_number":
facility.unit_number,
"unit_size":
facility.unit_capacity,
"unit_alias":
facility.unit_alias,
# capacities for the unit
"capacity_registered":
facility.capacity_registered,
"capacity_aggregate":
facility.capacity_aggregate,
# network specific fields (DUID is one)
"network_region":
facility.network_region,
})
if len(f.properties["duid_data"]) > 0:
records.append(f)
return records
for line in jsondata:
if not line.get('country'):
continue
country = line['country']
# don't need the country in the dict
del line['country']
#if country in data:
# data[country].append(line)
#else:
# data[country] = [ line ]
lat = float(line['lat'])
lng = float(line['lng'])
feature = Feature(geometry=Point((lng, lat)))
del line['lat']
del line['lng']
feature.properties = line
features.append(feature)
#except Exception as e:
# print str(e)
with open('../data/bordercrossings/bordercrossings.geojson', 'w') as outfile:
json.dump(FeatureCollection(features), outfile)
for air in (airft, airm):
air.close()
# GeoJSON output, to KML via ogr2ogr
logger.info("Converting to GeoJSON")
fc = []
for feature in collection:
geom = feature['geometry_ll']
if not geom:
logger.error("Feature without geometry: %s", feature)
continue
f = Feature()
f.properties = feature['properties']
f.properties.update({
'fillOpacity': 0.15,
})
class_ = f.properties.get('class')
from_ = int(f.properties.get('from (m amsl)'))
to_ = int(f.properties.get('to (m amsl)'))
if class_ in ['C', 'D', 'G', 'R']:
if from_ < 500:
f.properties.update({
'fillColor': '#c04040',
'color': '#c04040',
'fillOpacity': 0.35
})
elif from_ < 1000:
f.properties.update({'fillColor': '#c08040', 'color': '#c08040'})
