def __serialize__(self):
return {
'id': self.id,
'IMEI': self.imei,
'location': dumps(Feature(to_shape(self.location))),
'height': self.height,
'deployed': self.deployed,
'retrieved': self.retrieved,
'url': self.url
}
def convert(wkt):
utm = loads(wkt)
if isinstance(utm, LineString):
latlon_2d = LineString(
[utm_to_latlon(xy[0], xy[1]) for xy in list(utm.coords)])
elif isinstance(utm, Point):
latlon_2d = Point(
[utm_to_latlon(xy[0], xy[1]) for xy in list(utm.coords)][0])
else:
raise Exception("unknown geometry: %s" % type(utm))
return json.loads(dumps(latlon_2d))
def build_order_from_metadata(metadata_df,
idx,
row,
products_bundles,
sufix='sample_',
partial=False):
sample_id = idx
filtered_df = metadata_df[metadata_df.sample_id == sample_id]
# This will create a tuple with the item_type and with the corresponding associated item_ids'
items_by_type = [
(item_type,
filtered_df[filtered_df.item_type == item_type].id.to_list())
for item_type in filtered_df.item_type.unique()
]
products_order = [{
"item_type": k,
"item_ids": v,
"product_bundle": products_bundles[k]
} for k, v in items_by_type]
# clip to AOI
aoi_geojson = json.loads(dumps(row.geometry))
tools = [
{
'clip': {
'aoi': aoi_geojson
}
},
]
order_type = 'full'
if partial:
order_type = 'partial'
order_request = {
'name': f'{sufix}_{str(sample_id)}',
'order_type': order_type,
'products': products_order,
'tools': tools,
'delivery': {
'single_archive': True,
'archive_filename': '{{name}}.zip',
'archive_type': 'zip'
},
'notifications': {
'email': False
},
}
return order_request
def getGeoJSON(covid_date_inc):
print(f"covid_date_inc: {covid_date_inc}")
features = createJSON(getDate(covid_date_inc))
# json_docs = [json.dumps(feature) for feature in features]
# resp = jsonify(data=json_docs)
# return resp
feature_collection = FeatureCollection(features)
json_str = dumps(feature_collection, separators=(',', ':'))
# The below returns a GeoJSON string that an online GeoJSON validator validated
# When axios is used, instead of d3.json(), in the client the console displays
# an array of features
return json_str
def geojson_from_mask(mask,
thresh,
transform,
mode,
x_offset=0,
y_offset=0,
open_kernel=3,
close_kernel=3,
pixel_tolerence=0):
features = []
polys = geometries_from_mask(mask, thresh, transform, mode, x_offset,
y_offset, open_kernel, close_kernel,
pixel_tolerence)
features = [Feature(p) for p in polys]
feature_collection = FeatureCollection(features)
return dumps(feature_collection, indent=2)
def buffer(input_args):
#Casting to float
lat = float(input_args["lat"])
lon = float(input_args["lon"])
range = float(input_args["range"])
p = Point(lon, lat)
buffer = p.buffer(1.0)
feature = Feature(buffer, properties={'buffer_extent': '1'})
json_response = dumps(feature, indent=2)
resp = make_response(json_response, 200)
resp.mimetype = "application/vnd.geo+json" # So that browser knows what is the content type
return resp
def geometry_filter(geometry):
return {
'type': 'GeometryFilter',
'field_name': 'geometry',
'config': json.loads(dumps(geometry))
}
def handler(context, event):
b = event.body
if not isinstance(b, dict):
body = json.loads(b.decode('utf-8-sig'))
else:
body = b
context.logger.info("Event received !")
try:
# if we're not ready to handle this request yet, deny it
if not FunctionState.done_loading:
context.logger.warn_with('Function not ready, denying request !')
raise NuclioResponseError(
'The service is loading and is temporarily unavailable.',requests.codes.unavailable)
# MongoDB infos
db = FunctionConfig.target_db
collection = FunctionConfig.natura_collection
client = FunctionState.mongodb_client
# MongoDB SOC collection
natura = client[db][collection]
# parse request's body
feature = Helpers.parse_body(context,body)
search_distance = FunctionConfig.default_search_distance
if 'search' in event.fields:
search_distance = int(event.fields['search'])
# Get legal CRS
props = feature['properties']
if not ('crs' in props or 'legal_crs' in props):
context.logger.warn_with('CRS of the feature not found in properties, please specify one !')
raise NuclioResponseError(
'CRS of the feature not found in properties, please specify one !',requests.codes.bad)
crs_attr = 'legal_crs' if 'legal_crs' in props else 'crs'
if 'type' in props[crs_attr] and props[crs_attr]['type'] == 'EPSG':
code = props[crs_attr]['properties']['code']
epsg_crs = "{0}:{1}".format(props[crs_attr]['type'],code)
context.logger.info("Legal CRS: '{0}'".format(epsg_crs))
# Reprojection function to legal CRS
source = Proj(init=FunctionConfig.source_crs)
target = Proj(init=epsg_crs)
reproject = lambda x,y: pyproj.transform(source,target,x,y)
# Get a buffer of the target feature
buf = math.degrees((search_distance+100)/(6371 * 1000)) # in degree as we expected a EPSG:4326 CRS (WGS84)
search = shape(feature['geometry']).buffer(buf)
# Get natura2000 features intersecting the target feature
natura_features = list(natura.find({
"geometry": {
"$geoIntersects": {
"$geometry": geojson.loads(shapely_geojson.dumps(search))
}
}
}))
# Reprojection of natura2000 geometries in legal CRS
natura_geoms = [
transform(reproject,shape(n['geometry']))
for n in natura_features
]
# Reprojection of target geometry in legal CRS
parcel = transform(reproject,shape(feature['geometry']))
for i, f in enumerate(natura_features):
natura_geoms[i].value = f
result = []
for n in natura_geoms:
d = parcel.distance(n)
if d <= search_distance:
r = {
"_id": n.value['_id'],
"intersects": False,
"minDistance": d,
"properties": n.value['properties']['natura'],
"wktType": n.type.upper()
}
r.update(n.value['properties'])
r.pop('crs')
r.pop('natura')
r.pop('version')
if parcel.intersects(n):
i = parcel.intersection(n)
r['intersects'] = True
r['intersection'] = i.area if i.area else i.length
result.append(r)
context.logger.info("'{0}' natura2000 features processed".format(len(natura_features)))
except NuclioResponseError as error:
return error.as_response(context)
except Exception as error:
context.logger.warn_with('Unexpected error occurred, responding with internal server error',
exc=str(error))
message = 'Unexpected error occurred: {0}\n{1}'.format(error, traceback.format_exc())
return NuclioResponseError(message).as_response(context)
return context.Response(body=json.dumps({ 'natura2000': result }),
headers={},
content_type='application/json',
status_code=requests.codes.ok)
from sys import argv
import json
# pip install fiona shapely shapely-geojson
import fiona
from shapely.geometry import shape
from shapely_geojson import dumps
if len(argv) < 2:
print('usage: gen_map.py "New Mexico"')
quit()
target_state = argv[1]
states = []
for pol in fiona.open('tl_2019_us_state/tl_2019_us_state.shp'):
name = pol['properties']['NAME']
if name == target_state:
states.append(shape(pol['geometry']))
features = {"type": "FeatureCollection", "features": []}
for pol in fiona.open('tl_2019_us_aiannh/tl_2019_us_aiannh.shp'):
geo = shape(pol['geometry'])
for state in states:
if geo.intersects(state):
features["features"].append({
"geometry": json.loads(dumps(geo)),
"properties": pol['properties']
})
break
print(json.dumps(features, separators=(',', ':')))
#!/usr/bin/env python3
import shapefile
import shapely_geojson
from shapely.geometry import shape
shapefile = shapefile.Reader('tiling_grid/shape/sentinel2_tiles_world.shp')
records = shapefile.shapeRecords()
for feature in records:
#print(feature.shape.__geo_interface__)
print(feature.record[0])
geom = shape(feature.shape).buffer(-0.3)
geom2 = shapely_geojson.Feature(geom, properties={'name': feature.record[0]})
#print(shapely_geojson.dumps(geom2))
with open('tiling_grid/geojson/{0}.geojson'.format(feature.record[0]), 'w') as outfile:
outfile.write(shapely_geojson.dumps(shapely_geojson.FeatureCollection([geom2])))
def test_dumps():
point = Point(1, 1)
geojson1 = '{\n "type": "Point",\n "coordinates": [\n 1.0,\n 1.0\n ]\n}'
geojson2 = '{\n "coordinates": [\n 1.0,\n 1.0\n ],\n "type": "Point"\n}'
dumped = dumps(point, indent=1)
assert dumped == geojson1 or dumped == geojson2
def handler(context, event):
b = event.body
if not isinstance(b, dict):
body = json.loads(b.decode('utf-8-sig'))
else:
body = b
context.logger.info("Event received !")
try:
# if we're not ready to handle this request yet, deny it
if not FunctionState.done_loading:
context.logger.warn_with('Function not ready, denying request !')
raise NuclioResponseError(
'The service is loading and is temporarily unavailable.',
requests.codes.unavailable)
# MongoDB infos
db = FunctionConfig.target_db
collection = FunctionConfig.soc_collection
client = FunctionState.mongodb_client
# MongoDB SOC collection
soc = client[db][collection]
# parse request's body
feature = Helpers.parse_body(context, body)
# get original CRS of the feature
props = feature['properties']
if not ('crs' in props or 'legal_crs' in props):
context.logger.warn_with(
'CRS of the feature not found in properties, please specify one !'
)
raise NuclioResponseError(
'CRS of the feature not found in properties, please specify one !',
requests.codes.bad)
crs_attr = 'legal_crs' if 'legal_crs' in props else 'crs'
if 'type' in props[crs_attr] and props[crs_attr]['type'] == 'EPSG':
code = props[crs_attr]['properties']['code']
epsg_crs = "{0}:{1}".format(props[crs_attr]['type'], code)
# set the according reprojection lambda function
source = Proj(init=FunctionConfig.source_crs)
context.logger.info("Source CRS: {0}".format(
FunctionConfig.source_crs))
target = Proj(init=epsg_crs)
context.logger.info("Source CRS: {0}".format(epsg_crs))
reproject = lambda x, y: pyproj.transform(source, target, x, y)
## get colocated SOC data within a buffer of the requested feature
res = FunctionConfig.soc_resolution
buf = math.degrees(
res /
(6371 * 1000)) # in degree as we expected a EPSG:4326 CRS (WGS84)
search = shape(feature['geometry']).buffer(buf)
# get SOC raster data
geom = geojson.loads(shapely_geojson.dumps(search))
soc_data = list(
soc.find({"geometry": {
"$geoWithin": {
"$geometry": geom
}
}}, {"_id": 0}))
# get reprojected pixels
soc_pixels = [
transform(reproject, shape(p['geometry'])).buffer(res / 2,
cap_style=3)
for p in soc_data
]
# inject SOC value (elevation/z)
soc_attr = 'soc'
for i, v in enumerate(soc_data):
soc_pixels[i].value = v['properties'][soc_attr]
# reproject the requested feature to original CRS add add a buffer to smooth the computed result
parcel = transform(reproject,
shape(feature['geometry'])).buffer(res / 4)
s1, s2 = 0, 0
# process a weighted value according to the parcel's footprint on each intersected pixel
for px in soc_pixels:
area = parcel.intersection(px).area
s1 += area * px.value
s2 += area
# update the parcel with the weighted value if at least one pixel intersects it
if s2 != 0:
soc_average = round(s1 / s2, 6) # arbitrary
context.logger.info("'{0}' soc pixels processed".format(len(soc_data)))
except NuclioResponseError as error:
return error.as_response(context)
except Exception as error:
context.logger.warn_with(
'Unexpected error occurred, responding with internal server error',
exc=str(error))
message = 'Unexpected error occurred: {0}\n{1}'.format(
error, traceback.format_exc())
return NuclioResponseError(message).as_response(context)
return context.Response(body=json.dumps({'soc': soc_average}),
headers={},
content_type='application/json',
status_code=requests.codes.ok)
def getGeoJSON(covid_date_inc):
features = createJSON(getDate(covid_date_inc))
feature_collection = FeatureCollection(features)
json_str = dumps(feature_collection, separators=(',', ':'))
return json_str
def serialise(winery):
feature = create_feature(winery)
return dumps(feature, indent=2)
parser.add_argument('--outputpath',
required=True,
dest="outputpath",
help='The path to the output json file')
args = parser.parse_args()
data = pd.read_csv(args.inputpath, sep='\t', header=0, encoding='utf8')
grouped = data[['Winery', 'lat',
'lon']].groupby(['Winery', 'lat',
'lon']).size().reset_index(name='count')
features = list()
for i in grouped.itertuples():
nextwinery = Winery(i[1], float(i[2]), float(i[3]), i[4])
nextfeature = create_feature(nextwinery)
features.append(nextfeature)
feature_collection = FeatureCollection(features)
json = dumps(feature_collection, indent=2, ensure_ascii=False)
with codecs.open(args.outputpath, 'w', encoding="utf-8") as outfile:
outfile.write(json)
def get_geojson_feature(self, properties={}):
feature = Feature(self.shape, properties=properties)
return json.loads(dumps(feature))
def main(argv):
pc2points_nogeo = {}
with closing(io.open('bagadres-full.csv')) as io_file:
rows_read = 0
old_nr = 0
last_point = None
for row in csv.reader(io_file, delimiter=';'):
rows_read += 1
if rows_read == 1:
continue
# if rows_read % 100 == 0:
# print(rows_read)
if rows_read % 10000 == 0:
break
if row[1] == old_nr:
continue
old_nr = row[1]
p = shapely.geometry.Point(float(row[-2]), float(row[-1]))
if p == last_point:
continue
last_point = p
pc = row[4]
try:
pc2points_nogeo[pc].append(p)
except Exception as e:
pc2points_nogeo[pc] = [p]
# p.coords[:] + p.coords[:] + p.coords[:])
pc2points = {p: shapely.geometry.MultiPoint(q) for p, q in pc2points_nogeo.items()}
output = []
v_input = []
for p, poly in pc2points.items():
for p in poly.geoms:
v_input += p.coords
world = gpd.read_file(gpd.datasets.get_path('naturalearth_lowres'))
area = world[world.name == 'Netherlands']
area = area.to_crs(epsg=3395) # convert to World Mercator CRS
area_shape = area.iloc[0].geometry # get the Polygon
# Recoger todas las lineas y armarlas en poligonos.
vor = Voronoi(v_input)
lines = [shapely.geometry.LineString(vor.vertices[line]) for line in vor.ridge_vertices]
last_pc = ""
last_polys = []
polys_found = 0
polys = 0
result_polys = []
pc_polys = {}
for poly in shapely.ops.polygonize(lines):
polys += 1
pc = ""
old_polys_found = polys_found
for p2, poly2 in pc2points.items():
for p in poly2.geoms:
if poly.contains(p):
pc = p2
polys_found += 1
try:
pc_polys[pc].append(poly)
except LookupError as e:
pc_polys[pc] = [poly]
break
if old_polys_found == polys_found:
result_polys.append(Feature(poly, {'postcode': None}))
for pc, polys in pc_polys.items():
result_polys.append(
Feature(shapely.ops.unary_union(polys), {'postcode': pc}))
print(dumps(FeatureCollection(result_polys), indent=2))
return 0
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#Necessary pip install: shapely and shapely_geojson
#sudo pip install shapely shapely_geojson
#sudo pip install git+https://github.com/alekzvik/shapely-geojson
from shapely.geometry.point import Point
from shapely_geojson import dumps, Feature
p = Point(-8.2918, 41.4425) # (lon,lat) 41.4425° N, 8.2918° W
buffer = p.buffer(1.0)
feature = Feature(buffer, properties={'buffer_extent': '1'})
f1 = open("./data/guimaraes_buffer.geojson", "w")
f1.write(dumps(feature, indent=2))
if valid != 'Valid Geometry':
print('ERREUR:', nom, valid)
exit()
if Polygon(poly).area > 0.01 and nom not in ['CSG KOUROU 1']:
print('ERREUR:', nom, 'emprise trop importante')
exit()
return (Feature(Polygon(poly), {'nom': nom}))
pts = []
nom = None
features = []
for ligne in txt:
ligne = ligne[:-1]
match = re.match(check, ligne)
if match:
pts.append(match.group(1, 2, 3, 4, 6, 7, 8, 9, 11, 13))
else:
if nom:
features.append(pts2feature(pts, nom))
nom = None
if ligne != '':
nom = ligne
pts = []
if nom:
features.append(pts2feature(pts, nom))
print(dumps(FeatureCollection(features)))
