def _get_level_geometries(level):
buildings = level.buildings.all()
buildings_geom = cascaded_union([building.geometry for building in buildings])
spaces = {space.pk: space for space in level.spaces.all()}
holes_geom = []
for space in spaces.values():
if space.outside:
space.geometry = space.geometry.difference(buildings_geom)
columns = [column.geometry for column in space.columns.all()]
if columns:
columns_geom = cascaded_union([column.geometry for column in space.columns.all()])
space.geometry = space.geometry.difference(columns_geom)
holes = [hole.geometry for hole in space.holes.all()]
if holes:
space_holes_geom = cascaded_union(holes)
holes_geom.append(space_holes_geom.intersection(space.geometry))
space.geometry = space.geometry.difference(space_holes_geom)
for building in buildings:
building.original_geometry = building.geometry
if holes_geom:
holes_geom = cascaded_union(holes_geom)
holes_geom_prep = prepared.prep(holes_geom)
for obj in buildings:
if holes_geom_prep.intersects(obj.geometry):
obj.geometry = obj.geometry.difference(holes_geom)
results = []
results.extend(buildings)
for door in level.doors.all():
results.append(door)
results.extend(spaces.values())
return results
def parse_query(self, query):
super(MapPlotter, self).parse_query(query)
self.projection = query.get('projection')
self.area = query.get('area')
names = []
centroids = []
all_rings = []
data = None
for idx, a in enumerate(self.area):
if isinstance(a, basestring):
a = a.encode("utf-8")
sp = a.split('/', 1)
if data is None:
data = list_areas(sp[0], simplify=False)
b = [x for x in data if x.get('key') == a]
a = b[0]
self.area[idx] = a
else:
p = np.array(a['polygons'])
p[:, :, 1] = pyresample.utils.wrap_longitudes(p[:, :, 1])
a['polygons'] = p.tolist()
del p
rings = [LinearRing(po) for po in a['polygons']]
if len(rings) > 1:
u = cascaded_union(rings)
else:
u = rings[0]
all_rings.append(u)
if a.get('name'):
names.append(a.get('name'))
centroids.append(u.centroid)
nc = sorted(zip(names, centroids))
self.names = [n for (n, c) in nc]
self.centroids = [c for (n, c) in nc]
data = None
if len(all_rings) > 1:
combined = cascaded_union(all_rings)
else:
combined = all_rings[0]
self.combined_area = combined
combined = combined.envelope
self.centroid = list(combined.centroid.coords)[0]
self.bounds = combined.bounds
self.show_bathymetry = bool(query.get('bathymetry'))
self.show_area = bool(query.get('showarea'))
self.quiver = query.get('quiver')
self.contour = query.get('contour')
def processpoly(polylist):
print u"Полигоны"
for p in polylist:
pol = Polygon(p)
print pol
print u"Объединение"
print cascaded_union([Polygon(p) for p in polylist])
return 1
def fig_contains(fig1, fig2) -> float:
pgz1 = polygonize_figure(fig1)
pgz2 = polygonize_figure(fig2)
if len(pgz1) > 0 and len(pgz2) > 0:
plist1 = [Polygon(p) for p in pgz1]
plist2 = [Polygon(p) for p in pgz2]
u_polygon1 = cascaded_union(plist1)
u_polygon2 = cascaded_union(plist2)
if u_polygon1.contains(u_polygon2):
return True
return False
def fig_overlap_area(fig1, fig2) -> float:
pgzfg1 = polygonize_figure(fig1)
pgzfg2 = polygonize_figure(fig2)
if len(pgzfg1) > 0 and len(pgzfg2) > 0:
plist1 = [Polygon(p) for p in pgzfg1]
plist2 = [Polygon(p) for p in pgzfg2]
u_polygon1 = cascaded_union(plist1)
u_polygon2 = cascaded_union(plist2)
area = u_polygon1.intersection(u_polygon2).area
else:
area = 0.0
return area
def handle_special_countries(c):
c['Iceland'].patch = ops.cascaded_union([c['Iceland'].patch, c['England'].patch,
c['Ireland'].patch]).convex_hull
c['Madagascar'].patch = ops.cascaded_union([c['Madagascar'].patch,
c['Mozambique'].patch]).convex_hull
c['Madagascar'].__class__ = c['Iceland'].__class__
c['Malaysia'].patch = c['Malaysia'].patch.buffer(1)
c['Indonesia'].patch = c['Indonesia'].patch.buffer(1)
c['Indonesia'].__class__ = c['Iceland'].__class__
c['Malaysia'].__class__ = c['Iceland'].__class__
c['Hawaii'].continent = ''
c['Falkland Is.'].continent = ''
def alpha_shape(points, alpha):
"""
Compute the alpha shape (concave hull) of a set
of points.
@param points: Iterable container of points.
@param alpha: alpha value to influence the
gooeyness of the border. Smaller numbers
don't fall inward as much as larger numbers.
Too large, and you lose everything!
"""
if len(points) < 4:
# When you have a triangle, there is no sense
# in computing an alpha shape.
return geometry.MultiPoint(list(points)).convex_hull
#coords = np.array([point.coords[0] for point in points])
coords = np.array(points)
print(coords)
tri = Delaunay(coords)
edges = set()
edge_points = []
# loop over triangles:
# ia, ib, ic = indices of corner points of the
# triangle
for ia, ib, ic in tri.vertices:
pa = coords[ia]
pb = coords[ib]
pc = coords[ic]
# Lengths of sides of triangle
a = math.sqrt((pa[0]-pb[0])**2 + (pa[1]-pb[1])**2)
b = math.sqrt((pb[0]-pc[0])**2 + (pb[1]-pc[1])**2)
c = math.sqrt((pc[0]-pa[0])**2 + (pc[1]-pa[1])**2)
# Semiperimeter of triangle
s = (a + b + c)/2.0
# Area of triangle by Heron's formula
area = math.sqrt(s*(s-a)*(s-b)*(s-c))
circum_r = a*b*c/(4.0*area)
# Here's the radius filter.
#print circum_r
if circum_r < 1.0/alpha:
add_edge(edges, edge_points, coords, ia, ib)
add_edge(edges, edge_points, coords, ib, ic)
add_edge(edges, edge_points, coords, ic, ia)
m = geometry.MultiLineString(edge_points)
triangles = list(polygonize(m))
return (cascaded_union(triangles), edge_points)
print (cascaded_union(triangles), edge_points)
def display(self, feature_name = None, *args):
# allows function to be used by multiple processes, first option (when a feature_name is passed)
# is for viewing data, second option is for viewing created geometries
if feature_name:
geom = self.datasets[self.current_dataset].features[feature_name][0]
if geom.geom_type != ('Polygon' or 'MultiPolygon'):
self.dialog_text.set('This geometry is invalid. Please use a different dataset')
pass
geom = cascaded_union(geom) #to dissolve multipolygons
geom_bdry = geom.boundary
minx, miny, maxx, maxy = self.bg.bounds
w, h = maxx - minx, maxy - miny
fig = plt.figure(1, figsize = (5, 5), dpi = 180, frameon = False)
ax = fig.add_subplot(111)
ax.set_xlim(minx,maxx)
ax.set_ylim(miny,maxy)
for poly in self.bg:
bg_patch = PolygonPatch(poly, fc = 'lightsage', ec = 'k', alpha = 1)
ax.add_patch(bg_patch)
if geom.geom_type == 'MultiPolygon':
for poly in geom:
patch = PolygonPatch(poly, fc= 'teal', ec='navy', alpha = 0.5)
ax.add_patch(patch)
else:
patch = PolygonPatch(geom, fc='teal', ec='navy', alpha = 0.5)
ax.add_patch(patch)
plt.show()
else:
geom = args[0]
name = args[1]
geom = cascaded_union(geom) #to dissolve multipolygons
minx, miny, maxx, maxy = self.bg.bounds
w, h = maxx - minx, maxy - miny
fig = plt.figure(1, figsize = (5, 5), dpi = 180, frameon = False)
ax = fig.add_subplot(111)
ax.set_xlim(minx,maxx)
ax.set_ylim(miny,maxy)
for poly in self.bg:
bg_patch = PolygonPatch(poly, fc = 'lightsage', ec = 'k', alpha = 1)
ax.add_patch(bg_patch)
if geom.geom_type == 'MultiPolygon':
for poly in geom:
patch = PolygonPatch(poly, fc= 'teal', ec='navy', alpha = 0.5)
ax.add_patch(patch)
else:
patch = PolygonPatch(geom, fc='teal', ec='navy', alpha = 0.5)
ax.add_patch(patch)
plt.title(name)
plt.show()
def ConvertPolygons2LatLong(PolygonDict, CRS):
"""
Convert coordinates to latlong using pyproj
https://gis.stackexchange.com/questions/127427/transforming-shapely-polygon-and-multipolygon-objects
returns shapely Polygon/Multipolygon Dictionary
MDH
"""
# define the output coordinate system
Output_CRS = Proj({'init': "epsg:4326"})
NewPolygonDict = {}
#loop through polygon dict and convert to latlong
for Key, Poly in PolygonDict.iteritems():
if Poly.geom_type == 'Polygon':
# get x and y as arrays
x,y = Poly.exterior.coords.xy
lon,lat = transform(CRS, Output_CRS, x, y)
Shape = Polygon(zip(lon,lat))
#check for multipolygons
if Key in NewPolygonDict:
Polygons = [Shape, NewPolygonDict[Key]]
Shape = cascaded_union(Polygons)
#add converted polygon to new dictionary
NewPolygonDict[Key] = Shape
elif Poly.geom_type == 'MultiPolygon':
for SinglePoly in Poly:
# get x and y as arrays
x,y = SinglePoly.exterior.coords.xy
lon,lat = transform(CRS, Output_CRS, x, y)
Shape = Polygon(zip(lon,lat))
#check for multipolygons
if Key in NewPolygonDict:
Polygons = [Shape, NewPolygonDict[Key]]
Shape = cascaded_union(Polygons)
#add converted polygon to new dictionary
NewPolygonDict[Key] = Shape
return NewPolygonDict
def test_split():
print "Split donut by interior point"
donut = sg.Point(0, 0).buffer(2.0).difference(sg.Point(0, 0).buffer(1.0))
center = donut.centroid
res = split_horiz_by_point(donut, center)
print "Parts (should be 2): %s" % len(res)
dif = cascaded_union(res).symmetric_difference(donut).area
print "Difference: %s" % dif
print "Split donut by exterior point"
side = sg.Point(4,4)
res = split_horiz_by_point(donut, side)
print "Parts (should be 1): %s" % len(res)
dif = cascaded_union(res).symmetric_difference(donut).area
print "Difference: %s" % dif
def buffer(self, toBuffer, outFile, distance, dissolve):
with fiona.open(toBuffer, 'r') as input:
schema = input.schema
crs = input.crs
schema['geometry'] = 'Polygon'
buf_features = []
for f in input:
buf_features.append(( shape(f['geometry']).buffer(distance), f['properties'] ))
if dissolve == True:
buf_features = cascaded_union([geom for geom, prop in buf_features])
schema = {'geometry':buf_features.geom_type, 'properties':{'fid':'int'}}
buf_features = [(buf_features, {'fid':'1'})]
#in windows compiled shapely library python crashes if str has 255 characters
#works without this block in source compiled verions
#--------------------------------------------------
for k, v in schema['properties'].items():
if v[0:3] == 'str' and v[-3:] == '255':
schema['properties'][k] = 'str:254'
#--------------------------------------------------
with fiona.open(outFile, 'w', 'ESRI Shapefile', crs=crs, schema=schema) as output:
for geom, prop in buf_features:
output.write({'geometry': mapping(geom), 'properties':prop})
def merge_polygon(self): if self.zone_segment: if len(self.lines) > 0: self.reduce_lines() merge = [] for elmt in self.tmp_figs.elements: if elmt.active == 0: continue if elmt.element.is_empty: continue if elmt.element.geom_type == 'Polygon': merge.append(elmt.element) elif elmt.element.geom_type == 'MultiPolygon': for polygon in elmt.element: merge.append(polygon) tmp = cascaded_union(merge) if tmp.geom_type=='MultiPolygon': for poly in tmp: if poly.is_valid: self.figs.add(self.Figs(poly)) #else: # print "Invalid" if poly.interiors: for inter in poly.interiors: self.figs.add(self.Figs(Polygon(inter))) elif tmp.geom_type=='Polygon': self.figs.add(self.Figs(tmp)) if tmp.interiors: for inter in tmp.interiors: self.figs.add(self.Figs(Polygon(inter)))
def _proto_read(self, layer):
""" Read features for the layer based on the self.request. """
proto = self._get_protocol_for_layer(layer)
if layer.public:
return proto.read(self.request)
user = self.request.user
if user is None:
raise HTTPForbidden()
cls = proto.mapped_class
geom_attr = proto.geom_attr
ras = DBSession.query(RestrictionArea.area, RestrictionArea.area.ST_SRID())
ras = ras.join(RestrictionArea.roles)
ras = ras.join(RestrictionArea.layers)
ras = ras.filter(Role.id == user.role.id)
ras = ras.filter(Layer.id == layer.id)
collect_ra = []
use_srid = -1
for ra, srid in ras.all():
if ra is None:
return proto.read(self.request)
else:
use_srid = srid
collect_ra.append(to_shape(ra))
if len(collect_ra) == 0: # pragma: no cover
raise HTTPForbidden()
filter1_ = create_filter(self.request, cls, geom_attr)
ra = cascaded_union(collect_ra)
filter2_ = ga_func.ST_Contains(
from_shape(ra, use_srid),
getattr(cls, geom_attr)
)
filter_ = filter2_ if filter1_ is None else and_(filter1_, filter2_)
return proto.read(self.request, filter=filter_)
def isGalleryCovered(camerasState):
circles_array=[]
for (i, camera) in enumerate(camerasState):
if(camerasState[i]):
circles_array.append(Gallery.cameras[i].circle)
circles_union=cascaded_union(circles_array)
return (circles_union.intersection(Gallery.gallery_polygon)==Gallery.gallery_polygon)
def do(star, stars, vertices):
maxArea = 0
start_poly = onestar_to_poly(star, vertices)
adjTupleSet = getStarAdj(star, stars)
# Get all adjacent combination with polyno number of polygons
for polyno in range(1,len(adjTupleSet)+1):
print("combine with" + str(polyno) + "\n\n")
combis = itertools.combinations(adjTupleSet,polyno)
for combi in combis:
print("new combination")
poly = shapelyPolygon(start_poly)
# vertices of this combination
polyvert = star.copy()
for p in combi:
# pdb.set_trace()
addPoly = shapelyPolygon(onestar_to_poly(p, vertices))
poly = cascaded_union([poly, addPoly])
for v in p:
polyvert.append(v)
# pdb.set_trace()
polyvert = list(set(polyvert))
polyvert.sort()
print("Vertices", polyvert)
polyvert = onestar_to_poly(polyvert, vertices)
print("Area", poly.area)
print("Star", starise.kernel(list(range(len(polyvert))), polyvert))
print("\n")
def alpha_shape(points, alpha):
def add_edge(points, i, j):
if (i, j) in edges or (j, i) in edges:
return
edges.add((i, j))
edge_points.append((points[i], points[j]))
tri = DelaunayTri(points)
edges = set()
edge_points = []
for i1, i2, i3 in tri.vertices:
x1, y1 = tri.points[i1]
x2, y2 = tri.points[i2]
x3, y3 = tri.points[i3]
a = hypot(x1 - x2, y1 - y2)
b = hypot(x2 - x3, y2 - y3)
c = hypot(x3 - x1, y3 - y1)
s = (a + b + c) / 2.0
area = sqrt(s * (s - a) * (s - b) * (s - c))
radius = a * b * c / (4 * area)
if radius < 1.0 / alpha:
add_edge(tri.points, i1, i2)
add_edge(tri.points, i2, i3)
add_edge(tri.points, i3, i1)
shape = cascaded_union(list(polygonize(MultiLineString(edge_points))))
return shape
def dissolve (self, inFile, outFile):
# create dictionary for storing the uniqueRefs
uniqueRefs = {}
with fiona.open(inFile, 'r', encoding='utf-8') as input:
input_driver = input.driver
input_crs = input.crs
input_schema = {'geometry': 'MultiLineString','properties': {'ref'.encode("utf-8"): 'str:254'}}
with fiona.open(outFile, 'w', driver=input_driver, crs=input_crs, schema=input_schema, encoding='utf-8') as output:
for item in input:
# extract the key, if the 'ref' attribute is NOT called 'ref'
# you can insert the different attribute name HERE (and only HERE).
key = item['properties']['ids_and_re']
geom = shape(item['geometry'])
# find all motorways within the New Zealand mainland
# and remove all letters per
newZeaBox = [(17920614.01, -4033681.682),(20362002, -4054837.565),(20357771.35, -6073108.484),(17683668.157,-6068877.308)]
newZeaPoly = Polygon(newZeaBox)
if geom.within(newZeaPoly):
key = re.sub(r'\D',"", key)
if not geom.type.startswith('Multi'):
geom = [geom]
for g in geom:
if key in uniqueRefs:
uniqueRefs[key].append(g)
else:
uniqueRefs[key] = [g]
for key in uniqueRefs:
# omit lines that have blank 'ref' tags
if key is not None and key != 'None':
dissolve_feat = cascaded_union(uniqueRefs[key])
output.write({'geometry':mapping(dissolve_feat), 'properties': {'ref': key}})
def cascaded_union(shapes):
o = []
for shape in shapes:
if not hasattr(shape,'__geo_interface__'): raise TypeError("%r does not appear to be a shape"%shape)
o.append(geom.asShape(shape))
res = shops.cascaded_union(o)
return asShape(res)
def visit(self, ax, poly, poly_vor, c1, c2, x, y, splits):
scatter(ax, x, y)
polys = sum([h.polys for h in self._heap_visitors], [])
candidates_union = cascaded_union(polys)
points = {}
for h in self._heap_visitors:
for x, y in zip(h.x, h.y):
points[(x, y)] = np.array((x, y))
points = list(points.values()) # remove duplicates
points.sort(key=lambda p: distance.euclidean(self._p, p))
if self._mode == 'union':
ax.plot(self._p[0], self._p[1], marker='x', zorder=99, c='red', ms=10, mew=5)
draw_poly(ax, candidates_union, 'none', lw=2.0, hatch='x')
elif self._mode == 'dist':
ax.plot(self._p[0], self._p[1], marker='x', zorder=99, c='blue', ms=3, mew=1)
for p in points:
ax.plot([self._p[0], p[0]], [self._p[1], p[1]], 'r-')
draw_poly(ax, candidates_union, 'none', lw=2.0)
elif self._mode == 'top':
ax.plot(self._p[0], self._p[1], marker='x', zorder=99, c='blue', ms=3, mew=1)
for p in points[:self._nns]:
ax.plot([self._p[0], p[0]], [self._p[1], p[1]], 'r-')
c = plt.Circle(self._p, distance.euclidean(self._p, points[self._nns-1]), edgecolor='red', zorder=99, lw=1.0, fill=False, linestyle='dashed')
ax.add_artist(c)
draw_poly(ax, candidates_union, 'none', lw=2.0)
def run_contour_paths(pseudo, epsilon, evals):
# get paths
paths = pseudo.contour_paths(epsilon)
# check if pseudospectrum is correct by matching the parts of it
import shapely.geometry as geom
from shapely.ops import cascaded_union
# create circles
circles = [geom.Point(numpy.real(lamda), numpy.imag(lamda))
.buffer(epsilon) for lamda in evals]
exact_pseudo = cascaded_union(circles)
exact_paths = pseudopy.utils.get_paths(exact_pseudo)
N = len(paths)
assert(N == len(exact_paths))
# create polygons
polys = [geom.Polygon([(numpy.real(z), numpy.imag(z))
for z in path.vertices])
for path in paths]
exact_polys = [geom.Polygon([(numpy.real(z), numpy.imag(z))
for z in path.vertices])
for path in exact_paths]
# match elements by measuring intersections
M = numpy.zeros((N, N))
for (i, j) in product(range(N), range(N)):
M[i, j] = exact_polys[i].symmetric_difference(polys[j]).area
for i in range(N):
assert(numpy.min(M[i, :]) < 0.1*epsilon)
def Merger_Aggregate(path_in, path_out):
from shapely.ops import cascaded_union
from shapely.geometry import Point, MultiPolygon, shape, mapping
from fiona import collection
import sys
import shutil
from time import sleep
with collection(path_in, "r") as input:
schema = input.schema.copy()
print "Check point Alpha"
with collection(path_out, "w", "ESRI Shapefile", schema) as output:
bl = []
print "Check point Brovo"
total = len(input)
count = 0;
for f in input:
bl.append(shape(f['geometry']))
ml = cascaded_union(bl)
f['geometry'] = mapping(ml)
f['properties']['Shape_area'] = ml.area
output.write(f)
count +=1
sys.stdout.write("\r" + "[%-75s]" % ('='*((count*75)/total)))
sys.stdout.write(str((count*100)/total) + "%")
sys.stdout.flush()
sleep(0.25)
print "Done!!!"
def polygon_union(polygons): """Takes the union of shapely polygons attempting to avoid floating point issues""" if len(polygons) == 1: return polygons[0] U = cascaded_union([_scale_polygon(poly,'up') for poly in polygons]) return _scale_polygon(U,'down')
def pack(items):
shifted = [ ]
for i, item in enumerate(items):
shifted.append(
affinity.translate(item, (i%6)*15, (i//6)*15)
)
return ops.cascaded_union(shifted)
def createInputShapefileMethodB(input_shapefile):
input_shapefile_fullpath = os.path.join(sys.path[0], input_shapefile + ".shp")
if os.path.exists(input_shapefile_fullpath):
return input_shapefile_fullpath
iso3 = 'UGA'
countries = { 'TZA': { "name": 'tanzania', "srid": '32736' }, 'BGD': { "srid": '32645', "name": 'bangladesh' }, 'UGA': { "srid": '32635', "name": 'uganda' }, 'NGA': { "name": 'nigeria', "srid": '32632' }, 'KEN': { "name": 'kenya', "srid": '32636' } };
points = executeSQL("SELECT ST_ASTEXT(ST_TRANSFORM(geom, "+countries[iso3]['srid']+")) FROM public."+countries[iso3]['name']+"_cicos", returnRows=True)
points = [r[0].replace("POINT(","").replace(")","").split(" ") for r in points]
bufferDist = 5000
polygons = [Point(float(p[0]), float(p[1])).buffer(bufferDist) for p in points]
multi_polygon = cascaded_union(polygons)
multi_polygon = ogr.CreateGeometryFromWkt(multi_polygon.wkt)
sourceSR = osr.SpatialReference()
sourceSR.ImportFromEPSG(int(countries[iso3]['srid']))
targetSR = osr.SpatialReference()
targetSR.ImportFromEPSG(4326)
coordTrans = osr.CoordinateTransformation(sourceSR, targetSR)
multi_polygon.Transform(coordTrans)
shpDriver = ogr.GetDriverByName("ESRI Shapefile")
outDataSource = shpDriver.CreateDataSource(input_shapefile_fullpath)
outLayer = outDataSource.CreateLayer(input_shapefile, geom_type=ogr.wkbMultiPolygon)
featureDefn = outLayer.GetLayerDefn()
outFeature = ogr.Feature(featureDefn)
outFeature.SetGeometry(multi_polygon)
outLayer.CreateFeature(outFeature)
del outDataSource
return input_shapefile_fullpath
def c_union(self):
if self.fovs is not None:
polygons = [Polygon(mbr_to_path(fov.mbr())) for fov in self.fovs[0:self.fov_count]]
u = cascaded_union(polygons)
return u
else:
print None
def fetch(self, **kwargs):
name = kwargs.pop("name", None)
if not name:
raise RuntimeError("Mandatory argument 'name' not given")
q = self.build_query(name, **kwargs)
response = requests.get(self.url, params=q)
if response.status_code != 200:
raise GisDataFetchError("Could not fetch land type data from gis server.")
data = response.json()
polygons = []
print "Extracting {} {} features".format(len(data["features"]), name)
error_count=0
for feature in data["features"]:
shell = feature["geometry"]["rings"][0]
holes = feature["geometry"]["rings"][1:]
holes = holes if holes else None
polygon=Polygon(shell=shell, holes=holes)
if polygon.is_valid:
polygons.append(polygon)
else:
error_count +=1
if error_count>0:
print "gis polygon error count is",error_count
return cascaded_union(polygons)
def saveR(rectangles, A, cc, n):
zona = takeZona(n)
polis =[]
for r in rectangles:
polis.append(r[0])
union = affinity.rotate(cascaded_union(polis), -A, origin=cc)
dx = union.centroid.x-cc.x
dy = union.centroid.y-cc.y
print 'translate : ',dx, dy
data2save=()
for r in rectangles:
rotated=affinity.rotate(r[0], -A, origin=cc)
translated = affinity.translate(rotated, -dx, -dy)
#verificar si interseca
print zona.intersects(translated)
if zona.intersects(translated):
data = (n, A, r[1], r[2], "SRID=25831;"+str(translated))
data2save += (data,)
#print data
conn = db.connect(rootData)
c = conn.cursor()
c.executemany('''insert into elementsdiv ( name, ang, x, y, geometry ) values ( ?, ?, ?,?, GeomFromEWKT( ? ) )''', data2save )
conn.commit()
conn.close()
return
def getNeighborhoodsByAreas(conn, areaids, user):
print 'getting votes'
(blocks, allVotes) = vote_utils.getVotes(conn, areaids, user)
print 'got votes'
blocks_by_hoodid = defaultdict(list)
id_to_label = {}
for block in blocks:
votes = allVotes[block['geoid10']]
#print block['geoid10']
maxVotes = vote_utils.pickBestVotes(votes)
for maxVote in maxVotes:
blocks_by_hoodid[maxVote['id']].append(block)
id_to_label[maxVote['id']] = maxVote['label']
hoods = {}
print 'doing unions'
for (id, blocks) in blocks_by_hoodid.iteritems():
geoms = [asShape(eval(block['geojson_geom'])) for block in blocks]
blockids = [block['geoid10'] for block in blocks]
pop10 = sum([block['pop10'] for block in blocks])
housing10 = sum([block['housing10'] for block in blocks])
geom = cascaded_union(geoms)
hoods[id] = NeighborhoodArea(geom, blockids, pop10, housing10)
return (hoods, id_to_label)
def generate_paths(self, shapes, tool_d): tool_r = tool_d / 2.0 toolpath = [] for shp in shapes: toolpath.append( shp.buffer(tool_r) ) result = cascaded_union(toolpath) if result.geom_type == 'Polygon': opt_obj = result.simplify(tolerance=0.01, preserve_topology=False) tmp = self.add_holders(opt_obj.exterior, self.holder_size + tool_d, self.min_len) if type(tmp) == list: return tmp else: return [tmp] elif result.geom_type == 'MultiPolygon': tmp = [] for f in result: opt_obj = f.simplify(tolerance=0.01, preserve_topology=False) tmp2 = self.add_holders(opt_obj.exterior, self.holder_size + tool_d, self.min_len) if type(tmp2) == list: for item in tmp2: tmp.append(item) else: tmp.append( tmp2 ) return tmp
def build_aggregate(level, code, name, territories):
print 'Building aggregate "{0}" (level={1}, code={2})'.format(name, level, code)
polygons = []
for tlevel, tcode in territories:
try:
territory = Territory.objects.get(level=tlevel, code=tcode)
except Territory.DoesNotExist:
print 'Territory {0}/{1} not found'.format(tlevel, tcode)
continue
if not shape(territory.geom).is_valid:
print 'Skipping invalid polygon for {0}'.format(territory.name)
continue
if shape(territory.geom).is_empty:
print 'Skipping empty polygon for {0}'.format(territory.name)
continue
polygons.append(territory.geom)
geom = cascaded_union([shape(p) for p in polygons])
if geom.geom_type == 'Polygon':
geom = MultiPolygon([geom])
try:
territory = Territory.objects.get(level=level, code=code)
except Territory.DoesNotExist:
territory = Territory(level=level, code=code)
territory.name = name
territory.geom = geom.__geo_interface__
territory.save()
def cascaded_union(self):
"""Deprecated: Return the unary_union of all geometries"""
return cascaded_union(self.geometry.values)
def poly_iou(poly1, poly2):
poly = cascaded_union([poly1, poly2])
union = poly.area
intersection = poly1.area + poly2.area - union
return intersection / union
def geohashes_to_polygon(geohashes):
"""
:param geohashes: array-like. List of geohashes to form resulting polygon.
:return: shapely geometry. Resulting Polygon after combining geohashes.
"""
return cascaded_union([geohash_to_polygon(g) for g in geohashes])
def alpha_shape(points, alpha, centeraxis=None):
"""
Alpha Shapes Code by KEVIN DWYER, see
http://blog.thehumangeo.com/2014/05/12/drawing-boundaries-in-python/
Compute the alpha shape (concave hull) of a set
of points.
@param points: Iterable container of points.
@param alpha: alpha value to influence the
gooeyness of the border. Smaller numbers
don't fall inward as much as larger numbers.
Too large, and you lose everything!
with minor adaptions to Tag Maps clustering.
Notes:
see also floating point resolution issue:
https://stackoverflow.com/questions/8071382/points-left-out-when-nearby-in-scipy-spatial-delaunay
Consider replace with shapely.Delauney
http://kuanbutts.com/2017/08/17/delaunay-triangulation/
"""
if centeraxis is None:
centeraxis = False
if len(points) < 4:
# When you have a triangle,
# there is no sense
# in computing an alpha shape.
return geometry.MultiPoint(list(points)).convex_hull
def add_edge(edges, edge_points, coords, i, j):
"""
Add a line between the i-th and j-th points,
if not in the list already
"""
if (i, j) in edges or (j, i) in edges:
# already added
return
edges.add((i, j))
edge_points.append(coords[[i, j]])
coords = np.array([point.coords[0] for point in points])
# qhull_options = 'Qt'
# #To avoid this error,
# joggle the data by specifying the
# 'QJ' option to the DELAUNAY function.see:
# https://de.mathworks.com/matlabcentral/answers/94438-why-does-the-delaunay-function-in-matlab-7-0-r14-produce-an-error-when-passed-colinear-points?s_tid=gn_loc_drop
if centeraxis:
# Center axis for avoiding floating point precision issues
norm_co = coords[0]
coords = coords - norm_co
tri = Delaunay(coords)
# print problematic points:
# print(tri.coplanar)
# tri = Delaunay(coords,qhull_topions='QJ')
# #Version 3.1 added triangulated output ('Qt').
# It should be used for Delaunay triangulations
# instead of using joggled input ('QJ').
edges = set()
edge_points = []
# loop over triangles:
# vert_ia, ib, ic = indices of corner points of the
# triangle
for vert_ia, vert_ib, vert_ic in tri.vertices:
pa_v = coords[vert_ia]
pb_v = coords[vert_ib]
pc_v = coords[vert_ic]
# Lengths of sides of triangle
a_val = math.sqrt((pa_v[0] - pb_v[0])**2 + (pa_v[1] - pb_v[1])**2)
b_val = math.sqrt((pb_v[0] - pc_v[0])**2 + (pb_v[1] - pc_v[1])**2)
c_val = math.sqrt((pc_v[0] - pa_v[0])**2 + (pc_v[1] - pa_v[1])**2)
# Semiperimeter of triangle
s_res = (a_val + b_val + c_val) / 2.0
# Area of triangle by Heron's formula
try:
area = math.sqrt(s_res * (s_res - a_val) * (s_res - b_val) *
(s_res - c_val))
except ValueError:
return False
if area == 0:
return False
circum_r = a_val * b_val * c_val / (4.0 * area)
# Here's the radius filter.
# print circum_r
if circum_r < 1.0 / alpha:
add_edge(edges, edge_points, coords, vert_ia, vert_ib)
add_edge(edges, edge_points, coords, vert_ib, vert_ic)
add_edge(edges, edge_points, coords, vert_ic, vert_ia)
if centeraxis:
# return to original axis center
edge_points = [
np.array([edgepoint[0] + norm_co, edgepoint[1] + norm_co])
for edgepoint in edge_points
]
mmulti_line_str = geometry.MultiLineString(edge_points)
triangles = list(polygonize(mmulti_line_str))
return cascaded_union(triangles) # , edge_points
def stairs(self):
return cascaded_union([
stair.geometry for stair in self.query('stairs')
]).intersection(self.accessible)
def getTiles(data, bbox, lbl='1'):
points = {}
coord_list = []
polyCoordPositions = {}
voronoiTiles = {}
# track the position of each vertex of each geometry in the coordinates list passsed to scypi.voronoi
# this position is mapped to the id of the corresponding feature in polyCoordPositions
vert_cnt = 0
vor_data = VoronoiTiles.get_min_dists([d['geometry'] for d in data])
toPlot = []
for d_pos in range(len(vor_data)):
pid = data[d_pos]['attributes']['ssm_id']
polyCoordPositions[pid] = []
if isinstance(data[d_pos]['geometry'], Polygon):
coords = VoronoiTiles.sample_geometry(
vor_data[d_pos][0].exterior.coords[:], vor_data[d_pos][1])
toPlot.append(Polygon(coords))
coords = coords[:-1]
if isinstance(data[d_pos]['geometry'], LineString):
coords = VoronoiTiles.sample_geometry(
vor_data[d_pos][0].coords[:], vor_data[d_pos][1])
toPlot.append(LineString(coords))
if isinstance(data[d_pos]['geometry'], Point):
coords = VoronoiTiles.sample_geometry(
vor_data[d_pos][0].coords[:], vor_data[d_pos][1])
toPlot.append(Point(coords))
for coord in coords:
current_vert = vert_cnt
try:
current_vert = points[coord]
except:
points[coord] = current_vert
coord_list.append(coord)
vert_cnt += 1
polyCoordPositions[pid].append(current_vert)
lbl = 'map_data_' + lbl
# plot = plotGPD(toPlot, lbl)
# prepare bbox: add the maximum of min-dists as buffer around bbox
# - the rational here is that max of min-dists will include enough outer space and if
# sketch map distances are somewhat correlated to metric map distances this implies
# an increased chance of including objects on the periphery in the expected voronoi region
# First get the maximum distance
maxmin_dist = max([d[1] for d in vor_data])
minx, miny, maxx, maxy = np.array(bbox.bounds)
bbox = Polygon([(minx - maxmin_dist, miny - maxmin_dist),
(maxx + maxmin_dist, miny - maxmin_dist),
(maxx + maxmin_dist, maxy + maxmin_dist),
(minx - maxmin_dist, maxy + maxmin_dist)])
vor = Voronoi(coord_list, qhull_options="QJ Pp") # )# #UNCOMMENT
# fig = voronoi_plot_2d(vor, show_vertices= False, line_width=0.5, point_size=0.5)
# fig.set_size_inches((10, 10), forward=True)
# plt.xlim(vor.min_bound[0] - 0.5, vor.max_bound[0] + 0.5)
# plt.ylim(vor.min_bound[1] - 0.5 , vor.max_bound[1] + 0.5000)
# fig.savefig("orig_"+lbl+".svg")
# plt.show()
# plot
regions, vertices = VoronoiTiles.voronoi_finite_polygons_2d(
vor, bbox=bbox.bounds) #UNCOMMENT
plotTiles = []
# merge regions corresponding to polygons
unmerged_vor_regs = []
for pid in polyCoordPositions:
region_set = []
for pt_pos in polyCoordPositions[pid]:
pt_region = regions[vor.point_region[pt_pos]]
region_set.append(Polygon(vertices[pt_region]))
unmerged_vor_regs.append(Polygon(vertices[pt_region]))
try:
poly_vor_pg = cascaded_union(region_set)
except ValueError:
raise
# get the combined polygon back as np.array for matplotlib
# vor_pg = np.array(poly_vor_pg.exterior)
voronoiTiles[pid] = poly_vor_pg
plotRow = VoronoiTiles.attrByID(data, pid)
plotRow['feat_type'] = plotRow['feat_type'] + '_vor_region'
plotTiles.append({'attributes': plotRow, 'geometry': poly_vor_pg})
# only need this for visualdebug in matplotlib
#polyVoronoiMapping[pid] = vor_pg
lbl = 'voronoi_' + lbl
# plot = plotGPD(unmerged_vor_regs, lbl+'_unmerged') # UNCOMMENT
# addToPlot(vert_points, plot, lbl+'_unmerged')
# plot = plotGPD(plotTiles, lbl) # UNCOMMENT
# addToPlot(plotTiles, plot, lbl) # UNCOMMENT
return voronoiTiles
def image_poly(imgar):
"""
:param imgar:
:return:
"""
polys = []
over_poly = []
bar = Bar('Plotting Image Bounds', max=len(imgar))
# print("BAR", bar)
for cent in iter(imgar):
lat = float(cent['coords'][1])
lng = float(cent['coords'][0])
print("**Drones Lng, Lats**", lng, lat)
prps = cent['props']
fimy = float(prps['FlightRollDegree'])
fimx = float(prps['FlightPitchDegree'])
fimz = float(prps['FlightYawDegree'])
gimr = float(prps['GimbalRollDegree'])
gimp = float(prps['GimbalPitchDegree'])
gimy = float(prps['GimbalYawDegree'])
print("**Gimbal Pitch**", gimp, "\n **Gimbal Roll**", gimr, "\n **Gimbal Yaw**", gimy)
img_n = prps['File_Name']
# print("file name", img_n)
focal_lgth = prps['Focal_Length']
alt = float(prps["Relative_Altitude"])
cds1 = utm.from_latlon(lat, lng)
poly = new_gross(cds1, alt, focal_lgth, gimp, gimr, gimy, fimx, fimy, fimz)
project = partial(
pyproj.transform,
# pyproj.Proj(init=darepo),
pyproj.Proj(init='epsg:4326'), # source coordinate system
pyproj.Proj(init='epsg:3857')) # destination coordinate system
g2 = transform(project, poly)
over_poly.append(g2)
# Create GeoJSON
wow3 = geojson.dumps(poly)
wow4 = json.loads(wow3)
wow4 = rewind(wow4)
gd_feat = dict(type="Feature", geometry=wow4, properties=prps)
gs1 = json.dumps(gd_feat)
print("gs1", gs1)
polys.append(gd_feat)
bar.next()
union_buffered_poly = cascaded_union([l.buffer(.001) for l in over_poly])
print("UNION", union_buffered_poly)
polyz = union_buffered_poly.simplify(0.005, preserve_topology=False)
print("polyz", polyz)
projected = partial(
pyproj.transform,
pyproj.Proj(init='epsg:3857'), # source coordinate system
pyproj.Proj(init='epsg:4326')) # destination coordinate system
g3 = transform(projected, polyz)
print("G3", g3)
pop3 = geojson.dumps(g3)
# print("POP3", pop3)
pop4 = json.loads(pop3)
pop4 = rewind(pop4)
# print("pops4", pop4, "\npolys", polys)
ssx = json.dumps(polys)
# print("SSX", ssx)
bar.finish()
return polys, pop4
return len(to_subdivide)
while 1:
n_new = subdivide()
print("Subdivide made %d new nodes" % n_new)
if n_new == 0:
break
##
# Limit that to cdt cells for which the centroid is inside the domain
bounds = wkb2shp.shp2geom('region-bounds-v00.shp')
domain_poly = ops.cascaded_union(polys)
select_cells = [
domain_poly.contains(geometry.Point(cxy)) for cxy in cdt.cells_centroid()
]
select_cells = np.array(select_cells)
##
# come up with scales:
vc = cdt.cells_center(refresh=True)
diams = np.zeros(cdt.Ncells(), np.float64)
diams[:] = 0
for c in cdt.valid_cell_iter():
n = cdt.cells['nodes'][c, 0]
def get_one_polygon(self):
# f = self.polygons[0]
# for p in self.polygons[1:]:
# f = f.union(p)
return cascaded_union(self.polygons)
if countyName in counties:
counties[countyName].append(precinctName);
else:
counties[countyName] = [precinctName]
#print(counties)
#print(polygons)
jsonData = {}
#boundaryCoordinates cascaded_union(polygons)
for chunk in counties.keys():
precincts = counties[chunk]
countyCoordinates = []
for temp in precincts:
countyCoordinates.append(polygons[temp])
boundary = cascaded_union(countyCoordinates)
temp = {}
temp["precincts"] = counties[chunk]
temp["geometry"] = mapping(boundary)
jsonData[chunk] = temp
#adjacencyMap
adjacencyMap = {}
for i in polygons.keys():
polygonList = []
for j in polygons.keys():
if i == j:
continue
if polygons[i].touches(polygons[j]):
polygonList.append(j)
def get_levelconnectors(self, to_level=None):
queryset = self.query('levelconnectors').prefetch_related('levels')
if to_level is not None:
queryset = queryset.filter(levels=to_level)
return cascaded_union(
[levelconnector.geometry for levelconnector in queryset])
def swath_selection(swaths_selected=None):
''' Selection of swath. Swath information taken from the file:
Points+Lines_SW_24_stay.xlsx
Manual inpput check if there exists at least one valid swath otherwise
repeat the input
retrieves the extent for each swath, transforms it to Easting,Northing and
unions the swaths to one polynom
Parameters: None
Returns:
:swaths: list of selelected swaths, empty list if no swath is selected
:swaths_pnt_polygon: union of selected swaths polygon in points (RL, RP)
:swaths_geo_polygon: union of selected swaths polygon in (easting, northing)
'''
swath_file = r'./Points+Lines_SW_24_stay.xlsx'
swath_df = pd.read_excel(swath_file, skiprows=5)
valid_swaths = swath_df['Swath'].tolist()
swaths = []
if swaths_selected is None:
valid = False
while not valid:
_swaths = [
int(num[0]) for num in re.finditer(
r'\d+', input('Swaths to be included: [0 for all]: '))
]
if len(_swaths) == 1 and _swaths[0] == 0:
valid = True
break
for swath in _swaths:
if swath in valid_swaths:
swaths.append(swath)
if swaths:
valid = True
else:
if len(swaths_selected) == 1 and swaths_selected[0] == 0:
pass
else:
for swath in swaths_selected:
if swath in valid_swaths:
swaths.append(swath)
swaths_pnt_polygon = []
swaths_geo_polygon = []
for swath in swaths:
sd = swath_df[swath_df['Swath'] == swath].iloc[0]
point1 = (sd['1st RL'], sd['1st GP'])
point2 = (sd['1st RL'], sd['last GP'])
point3 = (sd['last RL'], sd['last GP'])
point4 = (sd['last RL'], sd['1st GP'])
_polygon = Polygon([point1, point2, point3, point4])
swaths_pnt_polygon.append(_polygon)
point1_coord = transformation(point1)
point2_coord = transformation(point2)
point3_coord = transformation(point3)
point4_coord = transformation(point4)
_polygon = Polygon(
[point1_coord, point2_coord, point3_coord, point4_coord])
swaths_geo_polygon.append(_polygon)
return swaths, cascaded_union(swaths_pnt_polygon), cascaded_union(
swaths_geo_polygon)
def get_map_divided_by_region(self, regions_dict, strategy='siting'):
all_xs = self.net.buses.x.values
all_ys = self.net.buses.y.values
minx = min(all_xs) - 5
maxx = max(all_xs) + 5
miny = min(all_ys) - 2
maxy = max(all_ys) + 2
fig = get_map_layout("", [minx, maxx, miny, maxy], False)
from functools import reduce
all_countries = sorted(
reduce(lambda x, y: x + y, list(regions_dict.values())))
offshore_shapes = get_shapes(all_countries, 'offshore')["geometry"]
offshore_shapes.index = [
'UK' if idx == "GB" else idx for idx in offshore_shapes.index
]
if strategy == "bus":
# Compute capacity potential per eez
tech_regions_dict = {"wind_offshore": offshore_shapes.values}
wind_capacity_potential_per_country = get_capacity_potential_for_regions(
tech_regions_dict)['wind_offshore']
wind_capacity_potential_per_country.index = offshore_shapes.index
# Compute generation per offshore bus
offshore_buses_index = self.net.buses[~self.net.buses.
onshore].index
total_generation_per_bus = pd.Series(index=offshore_buses_index)
total_max_capacity_per_bus = pd.Series(index=offshore_buses_index)
for idx in offshore_buses_index:
offshore_generators_index = self.net.generators[
self.net.generators.bus == idx].index
total_generation_per_bus[idx] = self.net.generators_t.p[
offshore_generators_index].values.sum()
total_max_capacity_per_bus[idx] = self.net.generators.loc[
offshore_generators_index, 'p_nom_max'].values.sum()
offshore_bus_region_shapes = self.net.buses.loc[
offshore_buses_index].offshore_region
feature_collection = []
all_caps_pd = pd.DataFrame(0.,
index=list(regions_dict.keys()),
columns=[
"ccgt", "load", "nuclear", "pv_utility",
"ror", "sto"
"wind_onshore", "wind_offshore"
])
for idx, regions in regions_dict.items():
# Get buses in region
buses_index = self.net.buses.loc[[
idx for idx in self.net.buses.index if idx[2:4] in regions
]].index
# Agglomerate regions together
region_shape = \
cascaded_union([shapely.wkt.loads(self.net.buses.loc[bus_id].onshore_region) for bus_id in buses_index])
centroid = region_shape.centroid
if isinstance(region_shape, sPolygon):
feature_collection += [
Feature(geometry=Polygon(
[list(region_shape.exterior.coords)]),
id=idx)
]
else:
feature_collection += \
[Feature(geometry=MultiPolygon([(list(poly.exterior.coords), ) for poly in region_shape]), id=idx)]
# Get all generators for those buses
generators = self.net.generators[self.net.generators.bus.isin(
buses_index)]
all_cap = dict.fromkeys(sorted(set(generators.type)))
for key in all_cap:
generators_type_index = generators[generators.type ==
key].index
all_cap[key] = np.sum(
self.net.generators_t.p[generators_type_index].values)
# Add STO output
storage_units = self.net.storage_units[
self.net.storage_units.bus.isin(buses_index)]
stos = storage_units[storage_units.type == "sto"]
all_cap['sto'] = np.sum(
self.net.storage_units_t.p[stos.index].values)
# Add wind_offshore
offshore_regions = [
r for r in regions if r in offshore_shapes.index
]
eez_region_shape = cascaded_union(
offshore_shapes.loc[offshore_regions]["geometry"])
offshore_generators = self.net.generators[self.net.generators.type
== 'wind_offshore']
if strategy == 'siting':
offshore_generators_in_region = \
offshore_generators[["x", "y"]].apply(lambda x: eez_region_shape.contains(Point(x[0], x[1])), axis=1)
offshore_generators_in_region_index = offshore_generators[
offshore_generators_in_region].index
if len(offshore_generators_in_region_index) != 0:
all_cap['wind_offshore'] = np.sum(
self.net.generators_t.
p[offshore_generators_in_region_index].values)
elif strategy == 'bus':
wind_capacity = wind_capacity_potential_per_country[
offshore_regions].sum()
# Compute intersection with all offshore shapes
all_cap['wind_offshore'] = 0
for off_idx, off_region_shape in offshore_bus_region_shapes.items(
):
off_region_shape = shapely.wkt.loads(off_region_shape)
intersection = off_region_shape.intersection(
eez_region_shape)
prop_cap_received_by_bus = (
intersection.area /
eez_region_shape.area) * wind_capacity
all_cap['wind_offshore'] += (
prop_cap_received_by_bus /
total_max_capacity_per_bus[off_idx]
) * total_generation_per_bus[off_idx]
x = (centroid.x - minx) / (maxx - minx)
y = (centroid.y - miny) / (maxy - miny)
title = idx
if ' ' in title:
title = f"{title.split(' ')[0]}<br>{title.split(' ')[1]}"
# Sort values
sorted_keys = sorted(list(all_cap.keys()))
sorted_values = [all_cap[key] for key in sorted_keys]
for i, key in enumerate(sorted_keys):
all_caps_pd.loc[idx, key] = sorted_values[i]
all_caps_pd.to_csv("generation_siting.csv")
fig.add_trace(
go.Pie(
values=sorted_values,
labels=sorted_keys,
hole=0.4,
text=[""] * len(all_cap.keys()),
textposition="none",
scalegroup='one',
domain=dict(x=[max(x - 0.14, 0),
min(x + 0.14, 1.0)],
y=[max(y - 0.14, 0),
min(y + 0.14, 1.0)]),
marker=dict(
colors=[self.tech_colors[key] for key in sorted_keys]),
sort=False,
title=dict(text=f"{title}",
position='middle center',
font=dict(size=20))))
feature_collection = FeatureCollection(feature_collection)
fig.add_trace(
go.Choropleth(
locations=list(regions_dict.keys()),
geojson=feature_collection,
z=list(range(len(regions_dict.keys()))),
text=list(regions_dict.keys()),
marker=dict(opacity=0.3),
colorscale='viridis',
autocolorscale=False,
reversescale=True,
marker_line_color='black',
marker_line_width=1.0,
))
# Add offshore regions
if 0:
feature_collection = []
for i, idx in enumerate(offshore_buses_index):
region_shape = shapely.wkt.loads(
self.net.buses.loc[idx].region)
if isinstance(region_shape, sPolygon):
feature_collection += [
Feature(geometry=Polygon(
[list(region_shape.exterior.coords)]),
id=idx)
]
else:
feature_collection += \
[Feature(geometry=MultiPolygon([(list(poly.exterior.coords), ) for poly in region_shape]), id=idx)]
feature_collection = FeatureCollection(feature_collection)
fig.add_trace(
go.Choropleth(
locations=offshore_buses_index.values,
geojson=feature_collection,
z=list(range(len(offshore_buses_index))),
text=offshore_buses_index,
marker=dict(opacity=0.5),
colorscale='plotly3',
autocolorscale=False,
reversescale=True,
marker_line_color='black',
marker_line_width=0.5,
))
return fig
def geometries(self, request, *args, **kwargs):
if not can_access_editor(request):
return PermissionDenied
Level = request.changeset.wrap_model('Level')
Space = request.changeset.wrap_model('Space')
level = request.GET.get('level')
space = request.GET.get('space')
if level is not None:
if space is not None:
raise ValidationError('Only level or space can be specified.')
level = get_object_or_404(Level.objects.filter(
Level.q_for_request(request)),
pk=level)
levels, levels_on_top, levels_under = self._get_levels_pk(
request, level)
# don't prefetch groups for now as changesets do not yet work with m2m-prefetches
levels = Level.objects.filter(pk__in=levels).filter(
Level.q_for_request(request))
# graphnodes_qs = request.changeset.wrap_model('GraphNode').objects.all()
levels = levels.prefetch_related(
Prefetch(
'spaces',
request.changeset.wrap_model('Space').objects.filter(
Space.q_for_request(request))),
Prefetch(
'doors',
request.changeset.wrap_model('Door').objects.filter(
Door.q_for_request(request))),
'buildings',
'spaces__holes',
'spaces__groups',
'spaces__columns',
'spaces__altitudemarkers',
# Prefetch('spaces__graphnodes', graphnodes_qs)
)
levels = {s.pk: s for s in levels}
level = levels[level.pk]
levels_under = [levels[pk] for pk in levels_under]
levels_on_top = [levels[pk] for pk in levels_on_top]
# todo: permissions
# graphnodes = tuple(chain(*(space.graphnodes.all()
# for space in chain(*(level.spaces.all() for level in levels.values())))))
# graphnodes_lookup = {node.pk: node for node in graphnodes}
# graphedges = request.changeset.wrap_model('GraphEdge').objects.all()
# graphedges = graphedges.filter(Q(from_node__in=graphnodes) | Q(to_node__in=graphnodes))
# graphedges = graphedges.select_related('waytype')
# this is faster because we only deserialize graphnode geometries once
# missing_graphnodes = graphnodes_qs.filter(pk__in=set(chain(*((edge.from_node_id, edge.to_node_id)
# for edge in graphedges))))
# graphnodes_lookup.update({node.pk: node for node in missing_graphnodes})
# for edge in graphedges:
# edge._from_node_cache = graphnodes_lookup[edge.from_node_id]
# edge._to_node_cache = graphnodes_lookup[edge.to_node_id]
# graphedges = [edge for edge in graphedges if edge.from_node.space_id != edge.to_node.space_id]
results = chain(
*(self._get_level_geometries(l) for l in levels_under),
self._get_level_geometries(level),
*(self._get_level_geometries(l) for l in levels_on_top),
*(space.altitudemarkers.all() for space in level.spaces.all()),
# graphedges,
# graphnodes,
)
return Response([obj.to_geojson(instance=obj) for obj in results])
elif space is not None:
space_q_for_request = Space.q_for_request(request)
qs = Space.objects.filter(space_q_for_request)
space = get_object_or_404(qs.select_related(
'level', 'level__on_top_of'),
pk=space)
level = space.level
doors = [
door for door in level.doors.filter(Door.q_for_request(
request)).all() if door.geometry.intersects(space.geometry)
]
doors_space_geom = cascaded_union(
[door.geometry for door in doors] + [space.geometry])
levels, levels_on_top, levels_under = self._get_levels_pk(
request, level.primary_level)
if level.on_top_of_id is not None:
levels = chain([level.pk], levels_on_top)
other_spaces = Space.objects.filter(
space_q_for_request,
level__pk__in=levels).prefetch_related('groups')
space = next(s for s in other_spaces if s.pk == space.pk)
other_spaces = [
s for s in other_spaces
if s.geometry.intersects(doors_space_geom) and s.pk != space.pk
]
all_other_spaces = other_spaces
if level.on_top_of_id is None:
other_spaces_lower = [
s for s in other_spaces if s.level_id in levels_under
]
other_spaces_upper = [
s for s in other_spaces if s.level_id in levels_on_top
]
else:
other_spaces_lower = [
s for s in other_spaces if s.level_id == level.on_top_of_id
]
other_spaces_upper = []
other_spaces = [s for s in other_spaces if s.level_id == level.pk]
space.bounds = True
buildings = level.buildings.all()
buildings_geom = cascaded_union(
[building.geometry for building in buildings])
for other_space in other_spaces:
if other_space.outside:
other_space.geometry = other_space.geometry.difference(
buildings_geom)
for other_space in chain(other_spaces, other_spaces_lower,
other_spaces_upper):
other_space.opacity = 0.4
other_space.color = '#ffffff'
for building in buildings:
building.opacity = 0.5
# todo: permissions
graphnodes = request.changeset.wrap_model(
'GraphNode').objects.all()
graphnodes = graphnodes.filter((Q(space__in=all_other_spaces))
| Q(space__pk=space.pk))
space_graphnodes = tuple(node for node in graphnodes
if node.space_id == space.pk)
graphedges = request.changeset.wrap_model(
'GraphEdge').objects.all()
graphedges = graphedges.filter(
Q(from_node__in=space_graphnodes)
| Q(to_node__in=space_graphnodes))
graphedges = graphedges.select_related('from_node', 'to_node',
'waytype')
areas = space.areas.filter(
Area.q_for_request(request)).prefetch_related('groups')
for area in areas:
area.opacity = 0.5
results = chain(
buildings, other_spaces_lower, doors, other_spaces,
[space], areas, space.holes.all(), space.stairs.all(),
space.ramps.all(), space.obstacles.all(),
space.lineobstacles.all(), space.columns.all(),
space.altitudemarkers.all(), space.wifi_measurements.all(),
space.pois.filter(
POI.q_for_request(request)).prefetch_related('groups'),
other_spaces_upper, graphedges, graphnodes)
return Response([obj.to_geojson(instance=obj) for obj in results])
else:
raise ValidationError('No level or space specified.')
polygons_B = [
sf["geometry"][1], #24
sf["geometry"][3], #28
sf["geometry"][4], #32
sf["geometry"][5], #44
sf["geometry"][6], #52
sf["geometry"][7], #53
sf["geometry"][11]
] #93
polygons_C = [
sf["geometry"][0], #11
sf["geometry"][9]
] #76
u_A = cascaded_union(polygons_A)
u_B = cascaded_union(polygons_B)
u_C = cascaded_union(polygons_C)
sf_zone = sf[:3]
sf_zone = sf_zone.drop(['code'], axis=1)
sf_zone['nom'] = ["A", "B", "C"]
sf_zone['geometry'] = [u_A, u_B, u_C]
sf_zone['value'] = [
df_zone["Zone_A_male_p"][2], df_zone["Zone_B_male_p"][2],
df_zone["Zone_C_male_p"][2]
]
deps = gv.Polygons(sf_zone, vdims=['nom', 'value'])
#input for the first layout
def alpha_shape_auto(xys, step=1, verbose=False):
'''
Computation of alpha-shape delineation with automated selection of alpha.
...
This method uses the algorithm proposed by Edelsbrunner, Kirkpatrick &
Seidel (1983) to return the tightest polygon that contains all points in
`xys`. The algorithm ranks every point based on its radious and iterates
over each point, checking whether the maximum alpha that would keep the
point and all the other ones in the set with smaller radii results in a
single polygon. If that is the case, it moves to the next point;
otherwise, it retains the previous alpha value and returns the polygon
as `shapely` geometry.
Arguments
---------
xys : ndarray
Nx2 array with one point per row and coordinates structured as X
and Y
step : int
[Optional. Default=1]
Number of points in `xys` to jump ahead after checking whether the
largest possible alpha that includes the point and all the
other ones with smaller radii
verbose : Boolean
[Optional. Default=False] If True, it prints alpha values being
tried at every step.
Returns
-------
poly : shapely.Polygon
Tightest alpha-shape polygon containing all points in `xys`
Example
-------
>>> pts = np.array([[0, 1], [3, 5], [4, 1], [6, 7], [9, 3]])
>>> poly = alpha_shape_auto(pts)
>>> poly.bounds
(0.0, 1.0, 9.0, 7.0)
>>> poly.centroid.x, poly.centroid.y
(4.690476190476191, 3.4523809523809526)
References
----------
Edelsbrunner, H., Kirkpatrick, D., & Seidel, R. (1983). On the shape of
a set of points in the plane. IEEE Transactions on information theory,
29(4), 551-559.
'''
if not HAS_JIT:
warn(
"Numba not imported, so alpha shape construction may be slower than expected."
)
if xys.shape[0] < 4:
from shapely import ops, geometry as geom
return ops.cascaded_union([geom.Point(xy)
for xy in xys])\
.convex_hull.buffer(0)
triangulation = spat.Delaunay(xys)
triangulation = spat.Delaunay(xys)
triangles = xys[triangulation.simplices]
a_pts = triangles[:, 0, :]
b_pts = triangles[:, 1, :]
c_pts = triangles[:, 2, :]
radii = r_circumcircle_triangle(a_pts, b_pts, c_pts)
radii[np.isnan(radii)] = 0 # "Line" triangles to be kept for sure
del triangles, a_pts, b_pts, c_pts
radii_sorted_i = radii.argsort()
triangles = triangulation.simplices[radii_sorted_i][::-1]
radii = radii[radii_sorted_i][::-1]
geoms_prev = alpha_geoms((1 / radii.max()) - EPS, triangles, radii, xys)
xys_bb = np.array([*xys.min(axis=0), *xys.max(axis=0)])
if verbose:
print('Step set to %i' % step)
for i in range(0, len(radii), step):
radi = radii[i]
alpha = (1 / radi) - EPS
if verbose:
print('%.2f%% | Trying a = %f'\
%((i+1)/radii.shape[0], alpha))
geoms = alpha_geoms(alpha, triangles, radii, xys)
if (geoms.shape[0] != 1) or not (np.all(xys_bb == geoms.total_bounds)):
break
else:
geoms_prev = geoms
return geoms_prev[0] # Return a shapely polygon
def areas_and_doors(self):
return cascaded_union([self.areas, self.raw_doors])
for level in levels:
# level = levels[0]
print "Processing level: {}".format(level)
level_path = os.path.join(base_dir, "{}.geojson".format(level))
feature_list = []
for ix, row in metadata_df.iterrows():
# for ix, row in metadata_df.loc[metadata_df["City Name"] == "Milan"].iterrows():
city_name = row["City Name"].replace(" ", "_")
fname = level + ".shp"
if level == "studyArea":
fname = "{}_{}".format(city_name, fname)
shp_path = os.path.join(shps_dir, city_name, fname)
shp = fiona.open(shp_path, "r")
if len(shp) > 1:
print "\tCombining {} features for {}".format(len(shp), city_name)
geom_shape = cascaded_union([shape(i["geometry"]) for i in shp]).buffer(0)
else:
geom_shape = shape(shp[0]["geometry"]).buffer(0)
# if "coordinates" in geom:
# geom = {
# "type": "Feature",
# "geometry": geom,
# }
geom = mapping(geom_shape)
if shp.crs["init"] != 'epsg:4326':
geom = reproject(geom, shp.crs["init"])
if geom["type"] == "Polygon":
geom = mapping(MultiPolygon([shape(geom)]))
props = convert_unicode(row.to_dict())
for i in props:
if isinstance(props[i], float) and math.isnan(props[i]):
def holes(self):
return cascaded_union([
holes.geometry for holes in self.query('holes').all()
]).intersection(self.areas)
def p2mp(da): # polygon to multipolygon
from shapely.ops import cascaded_union
return cascaded_union(
da) # https://stackoverflow.com/questions/36774049/
def accessible(self):
return self.areas.difference(
cascaded_union([self.holes, self.obstacles]))
def elevatorlevels(self):
return cascaded_union([
elevatorlevel.geometry
for elevatorlevel in self.query('elevatorlevels').all()
])
def areas(self):
return cascaded_union([self.rooms, self.outsides, self.elevatorlevels])
def shapes(self, shape_type=1):
"""Computes cluster shapes.
Parameters:
shape_type (int): The methods to use for computing cluster
shapes (allowed values: 1, 2 or 3; default: 1 - fastest).
Returns:
A GeoDataFrame containing the cluster shapes.
"""
pois = self._pois_in_clusters.to_geopandas_df()
eps_per_cluster = self._eps_per_cluster
if shape_type == 2:
cluster_borders = pois.groupby(
['cluster_id'], sort=False)['geometry'].agg([list, np.size])
join_df = pd.merge(cluster_borders,
eps_per_cluster,
left_index=True,
right_index=True,
how='inner')
cluster_list = []
for index, row in join_df.iterrows():
eps = row['eps']
cluster_i = []
for p in row['list']:
cluster_i.append(p.buffer(eps))
cluster_list.append(cascaded_union(cluster_i))
join_df['geometry'] = cluster_list
join_df['cluster_id'] = join_df.index
join_df.reset_index(drop=True, inplace=True)
join_df.drop(['list', 'cluster_size'], axis=1, inplace=True)
cluster_borders = gpd.GeoDataFrame(join_df,
crs=pois.crs,
geometry='geometry')
cluster_borders = cluster_borders[[
'cluster_id', 'size', 'geometry'
]]
elif shape_type == 3:
eps_dict = dict()
for index, row in eps_per_cluster.iterrows():
eps_dict[index] = row['eps']
circles_from_pois = pois.copy()
cid_size_dict = dict()
circles = []
for index, row in circles_from_pois.iterrows():
cid = row['cluster_id']
circles.append(row['geometry'].buffer(eps_dict[cid]))
cid_size_dict[cid] = cid_size_dict.get(cid, 0) + 1
circles_from_pois['geometry'] = circles
s_index = pois.sindex
pois_in_circles = gpd.sjoin(pois,
circles_from_pois,
how="inner",
op='intersects')
agged_pois_per_circle = pois_in_circles.groupby(
['cluster_id_left', 'index_right'],
sort=False)['geometry'].agg([list])
poly_list = []
cluster_id_list = []
for index, row in agged_pois_per_circle.iterrows():
pois_in_circle = row['list']
lsize = len(pois_in_circle)
if lsize >= 3:
poly = MultiPoint(pois_in_circle).convex_hull
poly_list.append(poly)
cluster_id_list.append(index[0])
temp_df = pd.DataFrame({
'cluster_id': cluster_id_list,
'geometry': poly_list
})
grouped_poly_per_cluster = temp_df.groupby(
['cluster_id'], sort=False)['geometry'].agg([list])
cluster_size_list = []
poly_list = []
for index, row in grouped_poly_per_cluster.iterrows():
poly_list.append(cascaded_union(row['list']))
cluster_size_list.append(cid_size_dict[index])
grouped_poly_per_cluster['geometry'] = poly_list
grouped_poly_per_cluster.drop(['list'], axis=1, inplace=True)
cluster_borders = gpd.GeoDataFrame(grouped_poly_per_cluster,
crs=pois.crs,
geometry='geometry')
cluster_borders['cluster_id'] = cluster_borders.index
cluster_borders['size'] = cluster_size_list
elif shape_type == 1:
cluster_borders = pois.groupby(
['cluster_id'], sort=False)['geometry'].agg([list, np.size])
cluster_borders['list'] = [
MultiPoint(l).convex_hull for l in cluster_borders['list']
]
cluster_borders.rename(columns={"list": "geometry"}, inplace=True)
cluster_borders.sort_index(inplace=True)
cluster_borders = gpd.GeoDataFrame(cluster_borders,
crs=pois.crs,
geometry='geometry')
cluster_borders.reset_index(inplace=True)
else:
raise Exception('Argument for shape_type could be 1, 2 or 3')
self._cluster_borders = cluster_borders
self._shape_type = shape_type
return cluster_borders
def raw_escalators(self):
return cascaded_union([
escalator.geometry for escalator in self.query('escalators').all()
])
def oneways_raw(self):
return cascaded_union(
[oneway.geometry for oneway in self.query('oneways')])
def levelconnectors(self):
return cascaded_union([
levelconnector.geometry
for levelconnector in self.query('levelconnectors')
])
def stuffedareas(self):
return cascaded_union([
stuffedarea.geometry for stuffedarea in self.query('stuffedareas')
])
def line_buffer(lat, lon, delta=1.0):
"""Creates buffer around geographical line using from pole rotated cap
outlines. This is far from perfect, but it does "a" job. There isn't much
more that one can and be spherically accurate. As long as the amount of
points in the line is fair this should have no problem to immitate a true
buffer.
Parameters
----------
lat : np.ndarray
latitudes
lon : np.ndarray
longitudes
delta : float, optional
epicentral distance to line, by default 1.0
Returns
-------
np.ndarray
Nx2 matrix with coordinates of a polygon that forms a buffer around
the line
Notes
-----
:Authors:
Lucas Sawade ([email protected])
:Last Modified:
2021.04.21 20.00 (Lucas Sawade)
"""
# Buffer circle around z axis
r = 1
phi = np.arange(0, 2 * np.pi, 2 * np.pi / 100)
theta = delta * np.pi / 180
# Circle around z axis in cartesian
x = r * np.sin(theta) * np.cos(phi)
y = r * np.sin(theta) * np.sin(phi)
z = r * np.cos(theta) * np.ones_like(phi)
points = np.vstack((x, y, z))
# Get circlse around the local coordinates
rcoordset = []
for _lat, _lon in zip(lat, lon):
# Convert line coordinates
x1 = geo2cart(1, _lat, _lon)
# Compute rotation matrix compute the new set of points
rpoints = Ra2b((0, 0, 1), x1) @ points
# Append x and y coordinates
rcoordset.append(cart2geo(rpoints[0, :], rpoints[1, :], rpoints[2, :]))
# Generate and combine polygons
polygons = []
circles = []
for _i, coords in enumerate(rcoordset):
circles.append((coords[2], coords[1]))
polygon = Polygon([(_x, _y) for _x, _y in zip(coords[2], coords[1])])
polygons.append(polygon)
# Combine from converted points
upoly = cascaded_union(polygons)
if upoly.type == 'MultiPolygon':
polyplot = [np.array(x.exterior.xy).T for x in upoly.geoms]
else:
polyplot = [np.array(upoly.exterior.xy).T]
return polyplot, circles
def escalatorslopes(self):
return cascaded_union([
s.geometry for s in self.query('escalatorslopes')
]).intersection(self.accessible)
