Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
def intersect_lad_areas_and_exchanges(exchanges, areas):
exchange_to_lad_area_lut = defaultdict(list)
idx = index.Index()
[idx.insert(0, shape(exchange['geometry']).bounds, exchange) for exchange in exchanges]
for area in areas:
for n in idx.intersection((shape(area['geometry']).bounds), objects=True):
area_shape = shape(area['geometry'])
exchange_shape = shape(n.object['geometry'])
if area_shape.intersects(exchange_shape):
exchange_to_lad_area_lut[n.object['properties']['id']].append({
'lad': area['properties']['name'],
})
return exchange_to_lad_area_lut
block_data = dataset.read(1, window=w, masked=True)
# handle NaNs for float rasters
block_data = np.ma.masked_invalid(block_data, copy=False)
total_count += int(block_data.size)
valid_data = block_data.compressed()
if valid_data.size == 0:
continue
valid_data_count += int(valid_data.size)
if np.any(block_data.mask):
hull_candidates = RasterDriver._hull_candidate_mask(~block_data.mask)
hull_shapes = [geometry.shape(s) for s, _ in features.shapes(
np.ones(hull_candidates.shape, 'uint8'),
mask=hull_candidates,
transform=windows.transform(w, dataset.transform)
)]
else:
w, s, e, n = windows.bounds(w, dataset.transform)
hull_shapes = [geometry.Polygon([(w, s), (e, s), (e, n), (w, n)])]
convex_hull = geometry.MultiPolygon([convex_hull, *hull_shapes]).convex_hull
tdigest.update(valid_data)
sstats.update(valid_data)
if sstats.count() == 0:
return None
convex_hull_wgs = warp.transform_geom(
def _parse_geoms(self, **kwargs):
""" Finds supported geometry types, parses them and returns the bbox """
bbox = kwargs.get('bbox', None)
wkt = kwargs.get('wkt', None)
geojson = kwargs.get('geojson', None)
bounds = None
if bbox is not None:
bounds = bbox
elif wkt is not None:
bounds = loads(wkt).bounds
elif geojson is not None:
bounds = shape(geojson).bounds
return self._project_bounds(bounds)
def to_shape(geom):
"""
Convert geometry to shapely geometry if necessary.
Parameters
----------
geom : shapely geometry or GeoJSON mapping
Returns
-------
shapely geometry
"""
return shape(geom) if isinstance(geom, dict) else geom
TileMatrixNSSize = float(round(TileMatrixTop - TileMatrixBottom, ROUND))
TileNumbers = tile_numbers(zoom)
TileNSSize = float(round(TileMatrixNSSize/TileNumbers[1], ROUND))
TileWESize = float(round(TileMatrixWESize/TileNumbers[0], ROUND))
TileMatrix = (TileMatrixLeft, TileMatrixTop, TileMatrixRight,
TileMatrixBottom, TileMatrixWESize, TileMatrixNSSize, TileNSSize,
TileWESize, TileNumbers)
with fiona.open(input_file) as input_shape:
geoms = []
for feature in input_shape:
geoms.append(shape(feature['geometry']))
union_geometry = cascaded_union(geoms)
# write WMTS tiles
outtiles_schema = {
'geometry': 'Polygon',
'properties': {'column': 'str', 'row': 'str'},
}
with fiona.open(outtiles, 'w', 'GeoJSON', outtiles_schema) as sink:
tiles = get_tiles(TileMatrix, union_geometry, parsed)
for tile in tiles:
col, row = tile
feature = {}
feature['properties'] = {}
feature['properties']['column'] = col
feature['properties']['row'] = row
tilegeom = get_boundaries(TileMatrix, col, row)
def _explode_geom(row):
# save each geo part in its own row
gsr = geopandas.GeoSeries([
poly for poly in geometry.shape(row['geometry'])
])
meta = row['properties']
return geopandas.GeoDataFrame(meta, geometry=gsr, index=gsr.index)
For Geometry returns only the shape
For GeometryCollection return a list of shapes
For Feature return the shape and the properties members
For FeatureCollection return a list of shapes and a list of properties
members.
"""
gj = GeoJSON
geometries = ["Point", "MultiPoint", "LineString",
"MultiLineString", "Polygon", "MultiPolygon"]
if gj['type'] in geometries:
return shape(gj)
if gj['type'] == 'GeometryCollection':
shapes = []
for geometry in gj['geometries']:
shapes.append(shape(geometry))
return shapes
if gj['type'] == 'Feature':
attributes = gj['properties']
return shape(gj['geometry']), attributes
if gj['type'] == "FeatureCollection":
shapes, attributes = ([], [])
for feature in gj['features']:
shapes.append(shape(feature['geometry']))
attributes.append(feature['properties'])
return shapes, attributes
def intersect_pcd_areas_and_exchanges(exchanges, areas):
exchange_to_pcd_area_lut = defaultdict(list)
# Initialze Rtree
idx = index.Index()
[idx.insert(0, shape(exchange['geometry']).bounds, exchange) for exchange in exchanges]
for area in areas:
for n in idx.intersection((shape(area['geometry']).bounds), objects=True):
area_shape = shape(area['geometry'])
exchange_shape = shape(n.object['geometry'])
if area_shape.intersects(exchange_shape):
exchange_to_pcd_area_lut[n.object['properties']['id']].append({
'postcode_area': area['properties']['postcode_a'],
})
return exchange_to_pcd_area_lut
polytypes = ("Polygon", "MultiPolygon")
if region_filter == "region":
# these polygon checks should cover all types of GeoJSON
if d.type == "FeatureCollection":
# this should check all features
gtype = d.features[0].geometry.type
if gtype not in polytypes:
raise ValueError(
"Geometry type in {} is {}, needs to be a polygon".format(
path_geojson, gtype
)
)
# combine features into 1 geometry
polys = []
for fcatch in d.features:
g = sg.shape(fcatch["geometry"])
polys.append(g)
# now simplify it to a rectangular polygon
bnds = unary_union(polys).bounds
geom = sg.mapping(sg.box(*bnds))
elif d.type == "Feature":
assert d.geometry.type in polytypes
geom = d.geometry
else:
assert d.type in polytypes
geom = d
# now simplify it to a rectangular polygon
bnds = sg.shape(geom).bounds
geom = sg.mapping(sg.box(*bnds))
else:
if d.type == "FeatureCollection":
nfeatures = len(d.features)