def plot_shapes(dict_of_multi_polygons, figsize):
# Define plot
fig = plt.figure(figsize=figsize)
ax = fig.add_subplot(111)
# Settings
number_of_polygon_groups = len(dict_of_multi_polygons.keys())
transparency = max(0.3, 0.3 + 0.7 / number_of_polygon_groups)
title_string = 'Plot showing polygons of:\n' + ', '.join(
dict_of_multi_polygons.keys())
# Find the boundaries of plot
minx, miny, maxx, maxy = (np.NaN, np.NaN, np.NaN, np.NaN)
for key in dict_of_multi_polygons.keys():
multi_polygons = dict_of_multi_polygons[key]
for polygon in multi_polygons:
minx_temp, miny_temp, maxx_temp, maxy_temp = polygon.bounds
minx, miny, maxx, maxy = (np.nanmin([minx, minx_temp]),
np.nanmin([miny, miny_temp]),
np.nanmax([maxx, maxx_temp]),
np.nanmax([maxy, maxy_temp]))
# Set boundaries
w, h = maxx - minx, maxy - miny
ax.set_xlim(12.4529, 12.6507)
ax.set_ylim(55.6150, 55.7326)
ax.set_aspect(1)
# Plot polygons
patches = []
list_of_list_of_lines = []
list_of_list_of_points = []
for key in dict_of_multi_polygons.keys():
multi_polygons = dict_of_multi_polygons[key]
if (multi_polygons[0].type == 'LineString') or (multi_polygons[0].type
== 'MultiLineString'):
list_of_list_of_lines.append(multi_polygons)
continue
if (multi_polygons[0].type == 'Point'):
list_of_list_of_points.append(multi_polygons)
continue
else:
mp = MultiPolygon(multi_polygons)
# Colourmap
cm = plt.get_cmap('RdBu')
num_colours = len(mp)
for idx, p in enumerate(mp):
colour = cm(1. * idx / num_colours)
patches.append(
PolygonPatch(p,
fc='grey',
ec='#555555',
alpha=transparency,
zorder=2))
# Plot lines
for list_of_lines in list_of_list_of_lines:
for line in list_of_lines:
x, y = line.xy
ax.plot(x,
y,
color='green',
linewidth=1,
zorder=2,
solid_capstyle='round')
# Plot points
for list_of_points in list_of_list_of_points:
for point in list_of_points:
patches.append(
PolygonPatch(point.buffer(0.001),
fc='red',
ec='#555555',
alpha=0.9,
zorder=1))
# Complete plot
ax.add_collection(PatchCollection(patches, match_original=True))
ax.set_xticks([])
ax.set_yticks([])
plt.title(title_string)
plt.show()
]
#DEFININDO ALPHA
alpha_shape = alphashape.alphashape(points, 0.)
# alpha_shape = alphashape.alphashape(points) # calculo do alpha automatico
fig, ax = plt.subplots()
ax.scatter(*zip(*points))
plt.xlim([np.min(dados_y), np.max(dados_y)])
plt.ylim([np.min(dados_z), np.max(dados_z)])
plt.axis("off")
# fig.savefig('/home/feijo/Documents/carvao_ufc/pilhasegmentada2/fig01_{}.png'.format(i))
ax.add_patch(PolygonPatch(alpha_shape, alpha=5))
# plt.show()
plt.xlim([np.min(dados_y),
np.max(dados_y)]) # limitando o espaço de plotar em y
plt.ylim([np.min(dados_z),
np.max(dados_z)]) # limitando o espaço de plotar em z
plt.axis("off") # sem eixos
fig.savefig(
'/home/feijo/Documents/carvao_ufc/pilhasegmentada1/fig02_{}.png'.
format(i))
print(i)
plt.close()
total = 0
for i in range(0, 1333):
t = np.arange(0, numFrames * dt, dt)
colors = ['b', 'g', 'r', 'c', 'm', 'k'] * 10
gs = gridspec.GridSpec(5, 1)
fig = plt.figure()
# plot trajectories
ax = plt.subplot(gs[0:3, 0])
ax.set_aspect('equal')
polygon_patches = []
if ("obstacles" in jsn):
for obs in jsn["obstacles"]:
poly = Polygon(obs)
polypatch = PolygonPatch(poly, color='gray', zorder=5)
ax.add_patch(polypatch)
for i in range(jsn["number_of_robots"]):
ax.plot(jsn["originals"][i]["x"],
jsn["originals"][i]["y"],
linestyle="dashed",
lw=2,
zorder=10,
color=colors[i],
alpha=0.8)
for i in range(jsn["number_of_robots"]):
x = []
y = []
for frame in range(len(jsn["points"])):
str(i),
color='#00000022',
fontsize=12.5,
zorder=-1,
ma='center',
ha='center',
va='center')
# Polygons --------------------------------------------------------------------
D = fun.disjoint_polygons(X, radius=.0075, n_angles=3)
for j in list(set(CLS_LB)):
matches = [key for key, val in enumerate(CLS_LB) if val in set([j])]
base = D.geometry[matches[0]]
for i in range(len(matches)):
base = base.union(D.geometry[matches[i]].buffer(0.00005))
ax.add_patch(
PolygonPatch(base, fc="none", ec='#6347ff', lw=1, alpha=.2, zorder=10))
ax.add_patch(
PolygonPatch(base, fc="none", ec='#ffffff', lw=.1, alpha=1, zorder=10))
ax.set_aspect(1)
ax.spines["top"].set_visible(False)
ax.spines["right"].set_visible(False)
ax.spines["bottom"].set_visible(False)
ax.spines["left"].set_visible(False)
ax.tick_params(axis='both',
which='both',
bottom=False,
top=False,
left=False,
right=False,
labelbottom=False,
labelleft=False)
def plot_line(ax, ob):
x, y = ob.xy
ax.plot(x, y, color=GRAY, linewidth=3, solid_capstyle='round', zorder=1)
line = LineString([(0, 0), (1, 1), (0, 2), (2, 2), (3, 1), (1, 0)])
fig = pyplot.figure(1, figsize=SIZE, dpi=90)
# 1
ax = fig.add_subplot(121)
plot_line(ax, line)
dilated = line.buffer(0.5, cap_style=3)
patch1 = PolygonPatch(dilated, fc=BLUE, ec=BLUE, alpha=0.5, zorder=2)
ax.add_patch(patch1)
ax.set_title('a) dilation, cap_style=3')
xrange = [-1, 4]
yrange = [-1, 3]
ax.set_xlim(*xrange)
ax.set_xticks(range(*xrange) + [xrange[-1]])
ax.set_ylim(*yrange)
ax.set_yticks(range(*yrange) + [yrange[-1]])
ax.set_aspect(1)
#2
ax = fig.add_subplot(122)
from matplotlib import pyplot
from shapely.geometry import Point
from shapely.ops import cascaded_union
from descartes import PolygonPatch
from figures import SIZE, BLUE, GRAY, set_limits
polygons = [Point(i, 0).buffer(0.7) for i in range(5)]
fig = pyplot.figure(1, figsize=SIZE, dpi=90)
# 1
ax = fig.add_subplot(121)
for ob in polygons:
p = PolygonPatch(ob, fc=GRAY, ec=GRAY, alpha=0.5, zorder=1)
ax.add_patch(p)
ax.set_title('a) polygons')
set_limits(ax, -2, 6, -2, 2)
#2
ax = fig.add_subplot(122)
u = cascaded_union(polygons)
patch2b = PolygonPatch(u, fc=BLUE, ec=BLUE, alpha=0.5, zorder=2)
ax.add_patch(patch2b)
ax.set_title('b) union')
def plotGraphObjectGroups(graphObjectGroups,
showPopulationCounts=False,
showGraphIds=False,
showDistrictNeighborConnections=False,
showGraphHeatmapForFirstGroup=False,
saveImages=False,
saveDescription='Temp'):
fig = pyplot.figure(figsize=(8, 8))
ax = fig.gca()
if showGraphHeatmapForFirstGroup:
count = -1
else:
count = 0
for graphObjectGroup in graphObjectGroups:
if len(graphObjectGroup) is not 0:
maxPopulation = max(
[block.population for block in graphObjectGroup])
heatMap = cm.get_cmap('Reds')
heatmapNormalizer = colors.LogNorm(vmin=0.1,
vmax=maxPopulation,
clip=True)
for graphObject in graphObjectGroup:
if showDistrictNeighborConnections:
for neighborGroup in graphObject.allNeighbors:
ax.add_line(
getLineForPair(graphObject, neighborGroup,
grayColor))
if showGraphHeatmapForFirstGroup and graphObjectGroups.index(
graphObjectGroup) is 0:
normalizedEnergy = heatmapNormalizer(
graphObject.population)
heatColor = heatMap(normalizedEnergy)
ax.add_patch(
PolygonPatch(graphObject.geometry,
fc=heatColor,
ec=(0, 0, 0, 0),
zorder=1))
else:
ax.add_patch(
PolygonPatch(graphObject.geometry,
fc=getColor(count),
ec=getColor(count),
alpha=0.5,
zorder=2))
if showPopulationCounts:
centerOfGroup = graphObject.geometry.centroid
ax.text(x=centerOfGroup.x,
y=centerOfGroup.y,
s=graphObject.population,
fontdict=font)
if showGraphIds:
centerOfGroup = graphObject.geometry.centroid
ax.text(x=centerOfGroup.x,
y=centerOfGroup.y,
s=graphObject.graphId,
fontdict=font)
count += 1
ax.axis('scaled')
if saveImages:
directoryPath = path.expanduser('~/Documents/RedistrictingImages')
if not path.exists(directoryPath):
makedirs(directoryPath)
filePath = path.expanduser('{0}/{1}.png'.format(
directoryPath, saveDescription))
pyplot.savefig(filePath)
pyplot.show()
def Draw_IDT(IDT_data):
IDT = IDT_data['IDT']
ax = plt.subplot(111)
branch0 = IDT_data['electrodes']['elect0']
branch1 = IDT_data['electrodes']['elect1']
removal0 = IDT_data['removal']['removal0']
removal1 = IDT_data['removal']['removal1']
reticule = IDT_data['reticule']
removal_center = IDT_data['removal']['removal_center']
for polygon in IDT[0]:
branch0 = branch0.union(polygon)
branch0 = branch0.difference(removal1)
if 'Hole_elect0' in IDT_data['removal'].keys():
branch0 = branch0.difference(IDT_data['removal']['Hole_elect0'])
branch0 = branch0.difference(removal_center)
if type(branch0) is shapely_geom.polygon.Polygon:
patch0 = PolygonPatch(branch0, fc=RED, ec=RED, alpha=0.5, zorder=2)
ax.add_patch(patch0)
else:
tkMessageBox.showwarning(title='Warning',
message='MultiPolygon detected')
for polygon in branch0.geoms:
patch0 = PolygonPatch(polygon, fc=RED, ec=RED, alpha=0.5, zorder=2)
ax.add_patch(patch0)
for polygon in IDT[1]:
branch1 = branch1.union(polygon)
branch1 = branch1.difference(removal0)
if 'Hole_elect1' in IDT_data['removal'].keys():
branch1 = branch1.difference(IDT_data['removal']['Hole_elect1'])
branch1 = branch1.difference(removal_center)
if type(branch1) is shapely_geom.polygon.Polygon:
patch1 = PolygonPatch(branch1, fc=BLUE, ec=BLUE, alpha=0.5, zorder=2)
ax.add_patch(patch1)
else:
tkMessageBox.showwarning(title='Warning',
message='MultiPolygon detected')
for polygon in branch1.geoms:
patch1 = PolygonPatch(polygon,
fc=BLUE,
ec=BLUE,
alpha=0.5,
zorder=2)
ax.add_patch(patch1)
for polygon in reticule:
patch_ret = PolygonPatch(polygon,
fc=GREY,
ec=GREY,
alpha=0.5,
zorder=3)
ax.add_patch(patch_ret)
ax.set_title('IDT geometry')
bounds0 = branch0.bounds
bounds1 = branch1.bounds
xrange = [
1.1 * min([bounds0[0], bounds1[0]]),
1.1 * max([bounds0[2], bounds1[2]])
]
yrange = [
1.1 * min([bounds0[1], bounds1[1]]),
1.1 * max([bounds0[3], bounds1[3]])
]
ax.axis([xrange[0], xrange[1], yrange[0], yrange[1]])
ax.set_aspect(1)
plt.show()
def GenerateNeighborhoodIndexMap(NeighborhoodIndex, ShapeFileLocation,
FileLocation, FileName):
fig, ax = plt.subplots(1, figsize=(14, 20))
minval = np.min(NeighborhoodIndex[:, 0].astype(float))
maxval = np.max(NeighborhoodIndex[:, 0].astype(float))
norm = mpl.colors.Normalize(minval, maxval)
#print minval,maxval
cmap = cm.RdPu
m = cm.ScalarMappable(norm=norm, cmap=cmap)
temp = []
ax.set_title('Estimated Value', fontsize=20)
with collection(ShapeFileLocation, "r", encoding='utf8') as input:
# schema = input.schema.copy()
schema = {'geometry': 'Polygon', 'properties': {'NEIGHBORH1': 'str'}}
for point in input:
BoolPass = True
ShapeFileDistrict = point['properties']['District_N']
ShapeFileMunicipality = point['properties']['Municipali']
temp.append([ShapeFileDistrict, ShapeFileMunicipality])
try:
select = np.logical_and(
NeighborhoodIndex[:, 1] == ShapeFileDistrict,
NeighborhoodIndex[:, 2] == ShapeFileMunicipality)
EstVal = float(NeighborhoodIndex[select][0][0])
BoolPass = True
except Exception as e:
BoolPass = False
pass
if BoolPass:
poly = Polygon(np.array(point['geometry']['coordinates'][0]))
x, y = poly.exterior.xy
ring_patch = PolygonPatch(poly,
fc=m.to_rgba(EstVal),
ec=m.to_rgba(EstVal),
alpha=0.9,
zorder=2)
ax.add_patch(ring_patch)
ax.plot(x,
y,
color='#000000',
alpha=0.85,
linewidth=1,
solid_capstyle='butt',
zorder=2)
x, y = poly.centroid.wkt.replace(')',
'').replace('(', '').replace(
'POINT ', '').split(' ')
rx = float(x)
ry = float(y)
cx = rx # + ring_patch.get_width()/2.0
cy = ry # + ring_patch.get_height()/2.0
reshaped_text = arabic_reshaper.reshape(
point['properties'][u'District_N'])
artext = get_display(reshaped_text)
ax.annotate(artext, (cx, cy),
color='black',
weight='bold',
fontsize=4,
ha='center',
va='center')
else:
poly = Polygon(np.array(point['geometry']['coordinates'][0]))
x, y = poly.exterior.xy
ring_patch = PolygonPatch(poly,
fc='#FFFFFF',
ec='#FFFFFF',
alpha=0.9,
zorder=2)
ax.add_patch(ring_patch)
ax.plot(x,
y,
color='#000000',
alpha=0.85,
linewidth=1,
solid_capstyle='butt',
zorder=2)
#Add the neighborhood name
x, y = poly.centroid.wkt.replace(')',
'').replace('(', '').replace(
'POINT ', '').split(' ')
rx = float(x)
ry = float(y)
cx = rx # + ring_patch.get_width()/2.0
cy = ry # + ring_patch.get_height()/2.0
reshaped_text = arabic_reshaper.reshape(
point['properties'][u'District_N'])
artext = get_display(reshaped_text)
ax.annotate(artext, (cx, cy),
color='black',
weight='bold',
fontsize=4,
ha='center',
va='center')
#Get the min and max values of the method
plt.xticks([])
plt.yticks([])
plt.savefig(FileLocation + '/' + FileName + '.png',
bbox_inches='tight',
dpi=300)
map_points = pd.Series([
Point(m(mapped_x, mapped_y))
for mapped_x, mapped_y in zip(biz_lons, biz_lats)
])
# In[12]:
df_map = pd.DataFrame({
'poly': [Polygon(xy) for xy in m.ctmap],
'ct_num': [float(tract['NAME']) for tract in m.ctmap_info]
})
# In[13]:
df_map['patches'] = df_map['poly'].map(lambda x: PolygonPatch(
x, fc='#555555', ec='#787878', lw=.25, alpha=.9, zorder=4))
# In[14]:
# Find out which census tract a business is in
for biz in pits_bizs:
biz['ct_num'] = 0
for biz, lat, lon in zip(pits_bizs, biz_lats, biz_lons):
map_point = Point(m(lon, lat))
for ct_num, poly in zip(df_map['ct_num'], df_map['poly']):
tract_poly = prep(poly)
if tract_poly.contains(map_point):
def Place_Electrodes(l,
phi_0,
lambda_approx,
electrodes_angle,
electrodes_thickness,
removal_thickness,
IDT_data,
electrode_type,
electrode_rotate_angle=0):
plot = False
Rlist = IDT_data['R']
Thetalist = IDT_data['Theta']
Rmin = []
Rmax = []
Rline = [[], []]
for polarity in range(len(Rlist)):
for i in range(len(Rlist[polarity])):
R = Rlist[polarity][i]
Theta = Thetalist[polarity][i]
Rmin = min([R.min(), Rmin])
Rmax = max([R.max(), Rmax])
xy = pol2cart(Theta, R)
if l == 0:
#Rline[polarity].append(shapely_geom.LinearRing(shapely_geom.asLineString(xy)))
Rline[polarity].append(shapely_geom.asLinearRing(xy))
else:
Rline[polarity].append(shapely_geom.asLineString(xy))
Rmax = 1.5 * Rmax
xyelect0 = pol2cart([electrodes_angle[0], electrodes_angle[0]],
[Rmin, Rmax])
xyelect1 = pol2cart([electrodes_angle[1], electrodes_angle[1]],
[Rmin, Rmax])
elect0 = shapely_geom.LineString([(xyelect0[0, 0], xyelect0[0, 1]),
(xyelect0[1, 0], xyelect0[1, 1])])
elect1 = shapely_geom.LineString([(xyelect1[0, 0], xyelect1[0, 1]),
(xyelect1[1, 0], xyelect1[1, 1])])
elect0 = shapely_affinity.rotate(elect0,
electrode_rotate_angle,
origin=(xyelect0[0, 0], xyelect0[0, 1]),
use_radians=False)
elect1 = shapely_affinity.rotate(elect1,
electrode_rotate_angle,
origin=(xyelect1[0, 0], xyelect1[0, 1]),
use_radians=False)
removal0 = deepcopy(elect0)
removal1 = deepcopy(elect1)
removal_center = shapely_geom.Point(
0.,
0.).buffer(Rmin -
electrodes_thickness * thickness_factor(electrode_type) / 2)
Elect0_polyg = elect0.buffer(electrodes_thickness / 2)
Elect1_polyg = elect1.buffer(electrodes_thickness / 2)
IDT_data['removal'] = {
'removal0': removal0.buffer(removal_thickness / 2),
'removal1': removal1.buffer(removal_thickness / 2),
'removal_center': removal_center
}
if False: #electrode_rotate_angle != 0. : #draw hollow electrode to avoid forcing opposite voltage to the wave
Hole_elect0 = elect0.buffer(
electrodes_thickness /
4) #up to 50% of the power branch can be hollow
Hole_elect1 = elect1.buffer(electrodes_thickness / 4)
Phi_0 = Electrode_pattern(electrode_type, phi_0)
N = Phi_0[0].size + Phi_0[1].size #number of electrodes over lambda
Hole_elect0 = Hole_elect0.intersection(
shapely_geom.MultiLineString(Rline[1]).buffer(lambda_approx /
(4 * N)))
Hole_elect1 = Hole_elect1.intersection(
shapely_geom.MultiLineString(Rline[0]).buffer(lambda_approx /
(4 * N)))
IDT_data['removal']['Hole_elect0'] = Hole_elect0
IDT_data['removal']['Hole_elect1'] = Hole_elect1
#Elect0_polyg = Elect0_polyg.difference(Hole_elect0)
#Elect1_polyg = Elect1_polyg.difference(Hole_elect1)
Rline = clean_edges(Rline, elect0, elect1)
IDT_data['electrodes'] = {'elect0': Elect0_polyg, 'elect1': Elect1_polyg}
IDT_data['Rline'] = Rline
if plot:
ax = plt.subplot(111)
patch1 = PolygonPatch(elect0.buffer(electrodes_thickness / 2),
fc=RED,
ec=RED,
alpha=0.5,
zorder=2)
ax.add_patch(patch1)
patch2 = PolygonPatch(elect1.buffer(electrodes_thickness / 2),
fc=BLUE,
ec=BLUE,
alpha=0.5,
zorder=2)
ax.add_patch(patch2)
ax.set_title('a) dilation, cap_style=3')
xrange = [-0.005, +0.005]
yrange = [-0.005, +0.005]
ax.axis([xrange[0], xrange[1], yrange[0], yrange[1]])
ax.set_aspect(1)
plt.show()
# 1
#ax = fig.add_subplot(121)
#plot_line(ax, line)
dilated = line.buffer(0.5)
#patch1 = PolygonPatch(dilated, fc=BLUE, ec=BLUE, alpha=0.5, zorder=2)
#ax.add_patch(patch1)
#2
ax = fig.add_subplot(122)
#patch2a = PolygonPatch(dilated, fc=GRAY, ec=GRAY, alpha=0.5, zorder=1)
#ax.add_patch(patch2a)
eroded = dilated.buffer(-0.3)
# GeoJSON-like data works as well
polygon = eroded.__geo_interface__
# >>> geo['type']
# 'Polygon'
# >>> geo['coordinates'][0][:2]
# ((0.50502525316941682, 0.78786796564403572), (0.5247963548222736, 0.8096820147509064))
patch2b = PolygonPatch(polygon, fc=BLUE, ec=BLUE, alpha=0.5, zorder=2)
print("poligono {}".format(polygon))
ax.add_patch(patch2b)
pyplot.show()
def export_to_shape_fiona(self,
shp_folder="",
shp_filename="",
free_zone_only=True,
export_mask=None,
shape_fields=None):
"""
export the grid to the shape file
using fiona since pyshp was not compatible with arcgis
:param export_mask: Mask to specify exactly which gridcells should be exported
:param free_zone_only:
:param shp_folder:
:param shp_filename:
"""
from fiona.crs import from_epsg, from_string
import fiona
proj = from_epsg(4326)
# proj = from_epsg(4269)
# proj = from_string("+units=m +lon_0=-97.0 +o_lon_p=180.0 +R=6370997.0 +o_proj=longlat +proj=ob_tran +o_lat_p=42.5")
print(proj)
print(dir(proj))
# proj = from_epsg(900913)
if isinstance(shp_folder, str):
folder = Path(shp_folder)
else:
folder = shp_folder
# create the directory if does not exist
if not folder.is_dir():
folder.mkdir()
schema = {
"geometry": "Polygon",
"properties": OrderedDict([("i", "int"), ("j", "int")])
}
if shape_fields is not None:
# additional fields
for field_name, field in shape_fields.items():
schema["properties"][field_name] = field.type_of_shp_field
with fiona.open(str(folder.joinpath(shp_filename)),
mode="w",
driver="ESRI Shapefile",
crs=proj,
schema=schema) as output:
lonr = [(i - (self.iref - 1)) * self.dx + self.xref
for i in range(self.ni)]
latr = [(j - (self.jref - 1)) * self.dy + self.yref
for j in range(self.nj)]
margin = 0
if free_zone_only:
margin = self.blendig + self.halo
start_i = margin
start_j = margin
end_i = self.ni - margin - 1
end_j = self.nj - margin - 1
if export_mask is None:
export_mask = np.ones((self.ni, self.nj), dtype=bool)
polygons = []
lake_fractions = []
for i in range(start_i, end_i + 1):
x = lonr[i]
for j in range(start_j, end_j + 1):
y = latr[j]
if not export_mask[i, j]:
continue
p00 = self.rll.toGeographicLonLat(x - self.dx / 2.0,
y - self.dy / 2.0)
p01 = self.rll.toGeographicLonLat(x - self.dx / 2.0,
y + self.dy / 2.0)
p11 = self.rll.toGeographicLonLat(x + self.dx / 2.0,
y + self.dy / 2.0)
p10 = self.rll.toGeographicLonLat(x + self.dx / 2.0,
y - self.dy / 2.0)
# p00 = (x - self.dx / 2.0, y - self.dy / 2.0)
# p01 = (x - self.dx / 2.0, y + self.dy / 2.0)
# p11 = (x + self.dx / 2.0, y + self.dy / 2.0)
# p10 = (x + self.dx / 2.0, y - self.dy / 2.0)
poly = Polygon(shell=[p00, p01, p11, p10, p00])
props = OrderedDict([("i", i + 1), ("j", j + 1)])
polygons.append(PolygonPatch(poly))
if shape_fields is not None:
lake_fractions.append(shape_fields["lkfr"][i, j])
for field_name, field in shape_fields.items():
converter = float if field.type_of_shp_field.startswith(
"float") else int
props[field_name] = converter(field[i, j])
output.write({
"geometry": mapping(poly),
"properties": props
})
def disegna_dbscan(labels,
facce,
facce_poligoni,
xmin,
ymin,
xmax,
ymax,
edges,
contours,
savefig=True,
format='pdf',
filepath='.',
savename='6_DBSCAN',
title=False):
'''
disegna le facce in base ai cluster ottenuti dal dbscan. Facce dello stesso cluster hanno stesso colore.
'''
fig, ax = setup_plot()
savename = os.path.join(filepath, savename + '.' + format)
colori_assegnati = []
colors = []
colors.extend(
('#800000', '#DC143C', '#FF0000', '#FF7F50', '#F08080', '#FF4500',
'#FF8C00', '#FFD700', '#B8860B', '#EEE8AA', '#BDB76B', '#F0E68C',
'#808000', '#9ACD32', '#7CFC00', '#ADFF2F', '#006400', '#90EE90',
'#8FBC8F', '#00FA9A', '#20B2AA', '#00FFFF', '#4682B4', '#1E90FF',
'#000080', '#0000FF', '#8A2BE2', '#4B0082', '#800080', '#FF00FF',
'#DB7093', '#FFC0CB', '#F5DEB3', '#8B4513', '#808080'))
#plt.subplot(224)
if title:
ax.set_title('6.dbscan')
for label in set(labels):
col = random.choice(colors)
colori_assegnati.append(col)
for index, l in enumerate(labels):
if (l == label):
f = facce[index]
f_poly = facce_poligoni[index]
f_patch = PolygonPatch(f_poly, fc=col, ec='BLACK')
ax.add_patch(f_patch)
ax.set_xlim(xmin, xmax)
ax.set_ylim(ymin, ymax)
sommax = 0
sommay = 0
for b in f.bordi:
sommax += (b.x1) + (b.x2)
sommay += (b.y1) + (b.y2)
xtesto = sommax / (2 * len(f.bordi))
ytesto = sommay / (2 * len(f.bordi))
ax.text(xtesto, ytesto, str(l), fontsize=8)
ascisse = []
ordinate = []
for edge in edges:
if (edge.weight >= 0.3):
ascisse.append(edge.x1)
ascisse.append(edge.x2)
ordinate.append(edge.y1)
ordinate.append(edge.y2)
ax.plot(ascisse, ordinate, color='k', linewidth=4.0)
del ascisse[:]
del ordinate[:]
ascisse = []
ordinate = []
for c1 in contours:
for c2 in c1:
ascisse.append(c2[0][0])
ordinate.append(c2[0][1])
ax.plot(ascisse, ordinate, color='0.8', linewidth=3.0)
del ascisse[:]
del ordinate[:]
if savefig:
plt.savefig(savename, bbox_inches='tight')
else:
plt.show()
return (colori_assegnati, fig, ax)
def save_animation(file_name, bbox, continent, current_df, states, num_iter, step):
# создаем рисунок
fig, ax = plt.subplots(figsize=(15, 15))
ax.set_xlabel('x, м')
ax.set_ylabel('y, м')
ax.set_xlim([bbox[0], bbox[2]])
ax.set_ylim([bbox[1], bbox[3]])
ax.add_patch(PolygonPatch(continent))
ax.axis('equal')
# добавляем поле скоростей
df = current_df[(current_df['time'] == 1) & (current_df['depth'] == 1)]
current_velocity = np.sqrt(df.loc[:, 'uo'] ** 2 + df.loc[:, 'vo'] ** 2)
q = ax.quiver(
df.loc[:, 'x'],
df.loc[:, 'y'],
df.loc[:, 'uo'],
df.loc[:, 'vo'],
current_velocity,
norm=colors.Normalize(vmin=current_velocity.min(), vmax=current_velocity.max()),
scale=7,
scale_units='width',
cmap='winter',
)
particles = {}
transform_offset = transforms.offset_copy(ax.transData, fig=fig, x=0.05, y=0.10, units='inches')
states_df = pd.read_csv('out.csv')
for particle_id, group_df in states_df.groupby('id'):
logger.info('Рисуем частицу %s', particle_id)
particles[particle_id] = {'line': ax.plot([], [], linestyle='-', marker='', color='red')[0],
'point': ax.plot([], [], linestyle='', marker='o')[0],
'text': ax.text(0, 0, '', transform=transform_offset)}
def init():
"""Initialize lines"""
result = [q]
for line in particles.values():
result.append(line['line'])
result.append(line['point'])
result.append(line['text'])
return result
last_day = 0
def update(frame):
"""Update frame"""
nonlocal last_day
logger.info('Рисуем кадр %s', frame)
ax.set_title('{}, час'.format(frame * step // 3600))
day = 1 + floor(frame * step / 86400)
if day > last_day:
df = current_df[(current_df['time'] == day) & (current_df['depth'] == 1)]
q.set_UVC(df['uo'], df['vo'], np.sqrt(df['uo'] ** 2 + df['vo'] ** 2))
last_day = day
result = [q]
for particle_id, particle_df in states_df.groupby('id'):
if frame < particle_df.shape[0]:
x = particle_df['x'].iloc[:frame + 1]
y = particle_df['y'].iloc[:frame + 1]
z = particle_df['z'].iloc[:frame + 1]
particles[particle_id]['line'].set_data(x, y)
particles[particle_id]['point'].set_data(x.iat[frame], y.iat[frame])
particles[particle_id]['point'].set_color(
'red' if particle_df['is_active'].iat[frame] else 'black'
)
particles[particle_id]['text'].set_text(f'{z.iat[frame]:.2f}')
particles[particle_id]['text'].set_x(x.iat[frame])
particles[particle_id]['text'].set_y(y.iat[frame])
result.append(particles[particle_id]['line'])
result.append(particles[particle_id]['point'])
result.append(particles[particle_id]['text'])
result.append(q)
return result
ani = animation.FuncAnimation(
fig,
update,
frames=num_iter - 1,
init_func=init,
interval=100,
blit=True,
)
ani.save(file_name, writer=animation.FFMpegFileWriter())
logger.info('Создан файл %s' % file_name)
def plot_aggregation(subject_id, model=None, cluster_masks=None, arms=None):
if model is None or cluster_masks is None or arms is None:
print(model)
model_path = os.path.join(
'cluster-output', '{}.json'.format(subject_id)
)
masks_path = os.path.join('cluster_masks', '{}.npy'.format(subject_id))
if not (os.path.exists(model_path) and os.path.exists(masks_path)):
return
with open(model_path) as f:
model = json.load(f)
with open(masks_path) as f:
cluster_masks = np.load(f)
arms = get_spiral_arms(subject_id, should_recreate=False)
annotations = gu.classifications[
gu.classifications['subject_ids'] == subject_id
]['annotations'].apply(json.loads)
models = annotations\
.apply(ash.remove_scaling)\
.apply(pa.parse_annotation)\
.apply(sanitize_model)
spirals = models.apply(lambda d: d.get('spiral', None))
geoms = pd.DataFrame(
models.apply(get_geoms).values.tolist(),
columns=('disk', 'bulge', 'bar')
)
logsps = [arm.reprojected_log_spiral for arm in arms]
disk_cluster_geoms = geoms['disk'][cluster_masks[0]]
bulge_cluster_geoms = geoms['bulge'][cluster_masks[1]]
bar_cluster_geoms = geoms['bar'][cluster_masks[2]]
aggregate_disk_geom = ash.make_ellipse(model['disk'])
aggregate_bulge_geom = ash.make_ellipse(model['bulge'])
aggregate_bar_geom = ash.make_box(model['bar'])
gal, angle = gu.get_galaxy_and_angle(subject_id)
pic_array, _ = gu.get_image(gal, subject_id, angle)
def ts(s):
return ash.transform_shape(s, pic_array.shape[0],
gal['PETRO_THETA'].iloc[0])
def tv(v):
return ash.transform_val(v, pic_array.shape[0],
gal['PETRO_THETA'].iloc[0])
imshow_kwargs = {
'cmap': 'gray',
'origin': 'lower',
'extent': [tv(0), tv(pic_array.shape[0])]*2,
}
fig, ((ax0, ax1), (ax2, ax3)) = plt.subplots(
ncols=2, nrows=2,
figsize=(10, 10),
sharex=True, sharey=True
)
ax0.imshow(pic_array, **imshow_kwargs)
for comp in geoms['disk'].values:
if comp:
ax0.add_patch(
PolygonPatch(ts(comp), fc='C0', ec='k',
alpha=0.2, zorder=3)
)
ax1.imshow(pic_array, **imshow_kwargs)
for comp in geoms['bulge'].values:
if comp:
ax1.add_patch(
PolygonPatch(ts(comp), fc='C1', ec='k',
alpha=0.5, zorder=3)
)
ax2.imshow(pic_array, **imshow_kwargs)
for comp in geoms['bar'].values:
if comp:
ax2.add_patch(
PolygonPatch(ts(comp), fc='C2', ec='k',
alpha=0.2, zorder=3)
)
ax3.imshow(pic_array, **imshow_kwargs)
for arm in arms:
for a in arm.arms:
ax3.plot(*tv(a).T)
for i, ax in enumerate((ax0, ax1, ax2, ax3)):
ax.set_xlim(imshow_kwargs['extent'][:2])
ax.set_ylim(imshow_kwargs['extent'][2:])
if i % 2 == 0:
ax.set_ylabel('Arcseconds from center')
if i > 1:
ax.set_xlabel('Arcseconds from center')
fig.subplots_adjust(wspace=0.05, hspace=0.05)
plt.savefig('drawn_shapes/{}.pdf'.format(subject_id), bbox_inches='tight')
plt.close()
fig, ((ax0, ax1), (ax2, ax3)) = plt.subplots(
ncols=2, nrows=2,
figsize=(10, 10),
sharex=True, sharey=True
)
ax0.imshow(pic_array, **imshow_kwargs)
for comp in disk_cluster_geoms.values:
ax0.add_patch(
PolygonPatch(ts(comp), fc='C0', ec='k', alpha=0.1, zorder=3)
)
if model['disk'] is not None:
aggregate_disk_geom = ash.make_ellipse(model['disk'])
ax0.add_patch(
PolygonPatch(ts(aggregate_disk_geom), fc='C1', ec='k', alpha=0.5,
zorder=3)
)
ax1.imshow(pic_array, **imshow_kwargs)
for comp in bulge_cluster_geoms.values:
ax1.add_patch(
PolygonPatch(ts(comp), fc='C1', ec='k', alpha=0.1, zorder=3)
)
if aggregate_bulge_geom is not None:
ax1.add_patch(
PolygonPatch(ts(aggregate_bulge_geom), fc='C2', ec='k', alpha=0.5,
zorder=3)
)
ax2.imshow(pic_array, **imshow_kwargs)
for comp in bar_cluster_geoms.values:
ax2.add_patch(
PolygonPatch(ts(comp), fc='C2', ec='k', alpha=0.1, zorder=3)
)
if aggregate_bar_geom is not None:
ax2.add_patch(
PolygonPatch(ts(aggregate_bar_geom), fc='C3', ec='k', alpha=0.5,
zorder=3)
)
ax3.imshow(pic_array, **imshow_kwargs)
for arm in arms:
plt.plot(*tv(arm.coords).T, '.', alpha=0.5, markersize=0.5)
for arm in logsps:
plt.plot(*tv(arm).T)
for i, ax in enumerate((ax0, ax1, ax2, ax3)):
ax.set_xlim(imshow_kwargs['extent'][:2])
ax.set_ylim(imshow_kwargs['extent'][2:])
if i % 2 == 0:
ax.set_ylabel('Arcseconds from center')
if i > 1:
ax.set_xlabel('Arcseconds from center')
fig.subplots_adjust(wspace=0.05, hspace=0.05)
plt.savefig('clustered_shapes/{}.pdf'.format(subject_id),
bbox_inches='tight')
plt.close()
fig = plt.figure(figsize=(10, 10))
ax = plt.gca()
ax.imshow(pic_array, **imshow_kwargs)
if aggregate_disk_geom is not None:
ax.add_patch(
PolygonPatch(ts(aggregate_disk_geom), fc='C0', ec='k', alpha=0.25,
zorder=3)
)
if aggregate_bulge_geom is not None:
ax.add_patch(
PolygonPatch(ts(aggregate_bulge_geom), fc='C1', ec='k', alpha=0.25,
zorder=3)
)
if aggregate_bar_geom is not None:
ax.add_patch(
PolygonPatch(ts(aggregate_bar_geom), fc='C2', ec='k', alpha=0.25,
zorder=3)
)
for arm in logsps:
plt.plot(*tv(arm).T, c='C3')
ax.set_xlim(imshow_kwargs['extent'][:2])
ax.set_ylim(imshow_kwargs['extent'][2:])
ax.set_ylabel('Arcseconds from center')
ax.set_xlabel('Arcseconds from center')
plt.savefig('aggregate_model/{}.pdf'.format(subject_id),
bbox_inches='tight')
plt.close()
# convert into map coordinates, unpacking and then repacking tuples
window = list(zip(*m(*list(zip(*window)))))
window_map = pd.DataFrame({'poly': [Polygon(window)]})
window_polygon = prep(MultiPolygon(list(window_map['poly'].values)))
m.readshapefile(baseFile, 'oakland', color='blue', zorder=2)
# set up a map dataframe
df_map = pd.DataFrame({
'poly': [Polygon(xy) for xy in m.oakland],
'id': [obj['OBJECTID'] for obj in m.oakland_info],
'zip': [obj['ZIP'] for obj in m.oakland_info],
'yearBuilt': [obj['YEARBUILT'] for obj in m.oakland_info]
})
# draw tract patches from polygons
df_map['patches'] = df_map['poly'].map(lambda x: PolygonPatch(
x, fc='none', ec='#888888', lw=.25, alpha=.9, zorder=4))
# color code the errors
for (yb, p, i) in zip(df_map.yearBuilt, df_map.patches, range(50000)):
if np.isnan(yb):
p.set_color('green')
elif yb < 1830: # because the oldest building in Oakland is from the 1850s
p.set_color('blue')
elif yb > 2016:
p.set_color('magenta')
## create colormap based on year built
#cmap_range = (1880, 1940)
#ncolors = 8
#yearBuilt_bins = np.linspace(min(cmap_range), max(cmap_range), ncolors+1)
#cmap = matplotlib.cm.coolwarm
def main():
n = 2 # Nr of agents
global dv, size_field, max_velocity, max_acceleration, t # change this later
size_field = 40
max_velocity = 6 ##0.5 these works for smaller radiuses, also produces the dancing thingy mentioned in the paper
max_acceleration = 2 ##0.5
dv = 0.05 #0.1 # Step size when looking for new velocities
t = 1 # timestep I guess
simulation_time = 400
radius = 1
pos = []
goal = []
# generate start and end positions
for t in range(n):
for i in range(n):
x = np.random.uniform(low=(size_field / 2 - 5),
high=(size_field / 2 + 5))
y = size_field + 10
goal.append((x, y))
for i in range(n):
x = np.random.uniform(low=(size_field - 25), high=(size_field))
y = 7
pos.append((x, y))
for i in range(n):
x = np.random.uniform(low=(0), high=(5))
y = 7
pos.append((x, y))
# pos = []
# for x in range(5,35,3):
# if x ==5:
# pos.append((x-2.5,2))
# else:
# pos.append((x-2.5,2))
# pos.append((2.5,x-2.5))
random.shuffle(pos)
#goals = pos[::-1]
agents = create_agents(n, radius, pos, goal)
#agentA = Agents([1,1], [0.5, 0.5], [8,8], radius,'r') # position, velocity, goal, radius, color
#agentB = Agents([8,8], [1, -0.5], [1,1], radius, 'b')
#agentC = Agents([1,8], [1, 2], [8,1], radius, 'y')
#agentD = Agents([8,1], [-1, 2], [1,8], radius, 'g')
#agentF = Agents([1, 5], [1, 2], [8, 5], radius, 'b')
#agentG = Agents([8, 5], [-1, 2], [1, 5], radius, 'b')
#agents = [agentA, agentB]#, agentC, agentD, agentF, agentG]
fig, ax = plt.subplots(
) # Fig ska man aldrig bry sig om om man inte vill ändra själva plotrutan
boundary_polygons = init_map_old(size_field, ax, radius)
# Consider the obstacles as agents with zero velocity! Don't consider these when updating velocities etc
#obstacle_agents = create_fake_agents(len(boundary_polygons), radius, boundary_polygons, 1)
time = 0
#avoid = [agents+obstacle_agents] # want to send in both agents and obstacles when creating VOs
while time < simulation_time:
for agent in agents:
VOs = agent.calculate_velocity_obstacles(agents, boundary_polygons)
#if retreat:
# print("Fly din dåre!")
# print(agent.vel)
# preffered_vel = [agent.vel[0]*(-1), agent.vel[1]*(-1)] # Helt om!
# print(preffered_vel)
#else:
preffered_vel = agent.find_preffered_velocity()
#print("preffered velocity", preffered_vel)
new_velocity = agent.avoidance_strategy(preffered_vel)
agent.pos = [
agent.pos[0] + new_velocity[0] * t,
agent.pos[1] + new_velocity[1] * t
]
agent.vel = new_velocity
if time == 0:
anims = []
patches = []
fs = []
for agent in agents:
dd = ax.plot(agent.pos[0], agent.pos[1], 'go')
anims.append(dd)
if len(agent.velocity_objects) != 0:
ww = PolygonPatch(agent.velocity_objects[0],
facecolor='#ff3333',
edgecolor='#6699cc',
alpha=0.5,
zorder=2)
patches.append(ww)
oo = ax.add_artist(agent.shape)
fs.append(oo)
#for patch in patches:
# ax.add_patch(patch)
#anim1, anim2, anim3, anim4, anim5, anim6 = ax.plot(agentA.pos[0],agentA.pos[1],'go',agentB.pos[0],agentB.pos[1],'bo', agentC.pos[0],agentC.pos[1],'ro', agentD.pos[0],agentD.pos[1],'yo', agentF.pos[0],agentF.pos[1],'yo', agentG.pos[0],agentG.pos[1],'yo')
#patch = PolygonPatch(agentA.velocity_objects[0], facecolor='#ff3333', edgecolor='#6699cc', alpha=0.5, zorder=2)
#ax.add_patch(patch)
#patch1a = PolygonPatch(agentA.velocity_objects[1], facecolor='#ff3333', edgecolor='#6699cc', alpha=0.5, zorder=2)
#ax.add_patch(patch1a)
#patch2 = PolygonPatch(agentA.velocity_objects[2], facecolor='#ff3333', edgecolor='#6699cc', alpha=0.5, zorder=2)
#ax.add_patch(patch2)
#patch3a = PolygonPatch(agentA.velocity_objects[3], facecolor='#ff3333', edgecolor='#6699cc', alpha=0.5, zorder=2)
#ax.add_patch(patch3a)
#patch4 = PolygonPatch(agentA.velocity_objects[4], facecolor='#ff3333', edgecolor='#6699cc', alpha=0.5, zorder=2)
#ax.add_patch(patch4)
ax.axis([-0, size_field, -0, size_field], 'equal')
#f = ax.add_artist(agentA.shape)
#f2 = ax.add_artist(agentB.shape)
#f3 = ax.add_artist(agentC.shape)
#f4 = ax.add_artist(agentD.shape)
#f5 = ax.add_artist(agentF.shape)
#f6 = ax.add_artist(agentG.shape)
#vel1 = ax.quiver(agentB.pos[0], agentB.pos[1], agentB.vel[0], agentB.vel[1], scale=6, scale_units ='width') ##in case we want velocity vector
#vel2 = ax.quiver(agentA.pos[0], agentA.pos[1], agentA.vel[0], agentA.vel[1], scale=6, scale_units ='width') ##in case we want velocity vector
#vel3 = ax.quiver(agentC.pos[0], agentC.pos[1], agentC.vel[0], agentC.vel[1], scale=6, scale_units ='width') ##in case we want velocity vector
#vel4 = ax.quiver(agentD.pos[0], agentD.pos[1], agentD.vel[0], agentD.vel[1], scale=6, scale_units ='width') ##in case we want velocity vector
else:
for (agent, anim, f) in zip(agents, anims, fs):
if len(agent.velocity_objects) != 0:
print("KDSDASd")
patch = PolygonPatch(agent.velocity_objects[0],
facecolor='#ff3333',
edgecolor='#6699cc',
alpha=0.5,
zorder=2)
ax.add_patch(patch)
anim[0].set_data(agent.pos[0], agent.pos[1])
f.center = agent.pos[0], agent.pos[1]
ax.plot(agent.goal[0], agent.goal[1], 'r*')
#anim2.set_data(agentB.pos[0], agentB.pos[1])
#anim3.set_data(agentC.pos[0], agentC.pos[1])
#anim4.set_data(agentD.pos[0], agentD.pos[1])
#anim5.set_data(agentF.pos[0], agentF.pos[1])
#anim6.set_data(agentG.pos[0], agentG.pos[1])
#velocity_object = Polygon([pos11, tp22, tp11])
#s11 = patch.get_path()
#print(s11)
#patch.bounds= (ps11, tp22, tp11)# = PolygonPatch(agentA.velocity_objects[0], facecolor='#ff3333', edgecolor='#6699cc', alpha=0.5, zorder=2)
#print(type(patch))
#patch.remove()
#patch = PolygonPatch(agentA.velocity_objects[0], facecolor='#ff3333', edgecolor='#6699cc', alpha=0.5, zorder=2)
#ax.add_patch(patch)
#patch1a.remove()
#patch1a = PolygonPatch(agentA.velocity_objects[1], facecolor='#ff3333', edgecolor='#6699cc', alpha=0.5, zorder=2)
#ax.add_patch(patch1a)
#patch2.remove()
#patch2 = PolygonPatch(agentA.velocity_objects[2], facecolor='#ff3333', edgecolor='#6699cc', alpha=0.5, zorder=2)
#ax.add_patch(patch2)
#patch3a.remove()
#patch3a = PolygonPatch(agentA.velocity_objects[3], facecolor='#ff3333', edgecolor='#6699cc', alpha=0.5, zorder=2)
#ax.add_patch(patch3a)
#patch4.remove()
#patch4 = PolygonPatch(agentA.velocity_objects[4], facecolor='#ff3333', edgecolor='#6699cc', alpha=0.5, zorder=2)
#ax.add_patch(patch4)
# patch2.remove()
# patch2 = PolygonPatch(agentB.velocity_objects[0], facecolor='#FFFF00', edgecolor='#FFFF00', alpha=0.5, zorder=2)
# ax.add_patch(patch2)
# patch3.remove()
# patch3 = PolygonPatch(agentC.velocity_objects[0], facecolor='#FFFF00', edgecolor='#FFFF00', alpha=0.5, zorder=2)
# ax.add_patch(patch3)
# patch4.remove()
# patch4 = PolygonPatch(agentD.velocity_objects[0], facecolor='#FFFF00', edgecolor='#FFFF00', alpha=0.5, zorder=2)
# ax.add_patch(patch4)
#f.center= agentA.pos[0],agentA.pos[1]
#f2.center = agentB.pos[0], agentB.pos[1]
#f3.center = agentC.pos[0], agentC.pos[1]
#f4.center = agentD.pos[0], agentD.pos[1]
#f5.center = agentF.pos[0], agentF.pos[1]
#f6.center = agentG.pos[0], agentG.pos[1]
#vel1.remove()
#vel2.remove()
#vel3.remove()
#vel4.remove()
#vel1 = ax.quiver(agentB.pos[0], agentB.pos[1], agentB.vel[0], agentB.vel[1], scale=6, scale_units ='width') ##in case we want velocity vector
#vel2 = ax.quiver(agentA.pos[0], agentA.pos[1], agentA.vel[0], agentA.vel[1], scale=6, scale_units ='width') ##in case we want velocity vector
#vel3 = ax.quiver(agentC.pos[0], agentC.pos[1], agentC.vel[0], agentC.vel[1], scale=6, scale_units ='width') ##in case we want velocity vector
#vel4 = ax.quiver(agentD.pos[0], agentD.pos[1], agentD.vel[0], agentD.vel[1], scale=6, scale_units ='width') ##in case we want velocity vector
#f = ax.add_artist(agentA.shape)
#f2 = ax.add_artist(agentB.shape)
#ax.quiver(agentB.pos[0], agentB.pos[1], agentB.vel[0], agentB.vel[1], scale=6, scale_units ='width') ##in case we want velocity vector
#ax.quiver(agentA.pos[0], agentA.pos[1], agentA.vel[0], agentA.vel[1], scale=6, scale_units ='width') ##in case we want velocity vector
#ax.plot(agentA.goal[0], agentA.goal[1],'r*')
#ax.plot(agentB.goal[0], agentB.goal[1],'g*')
#ax.plot(agentC.goal[0], agentC.goal[1],'b*')
#ax.plot(agentD.goal[0], agentD.goal[1],'y*')
#ax.plot(agentF.goal[0], agentF.goal[1],'b*')
#ax.plot(agentG.goal[0], agentG.goal[1],'b*')
time += 1
print("time:", time)
plt.pause(0.1)
def main():
j = 1
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
mng = plt.get_current_fig_manager()
mng.full_screen_toggle()
cleo = True
listpiw = []
dancing = 0
freeze = 0
downwind_leeway, crosswind_leeway = leeway()
errord = 0.12
errorc = 0.094
comprised = 0
fov = 20
plt.ion()
plt.grid()
soph = [] #holds all search areas - for all timestamps
foundline = False
eliminate_bug = True
elly = False
###INITIAL POSITION###
op = 50
gg = 1000
errors = []
for error in range(200):
errors.append([
normalfunction(0.12, False),
normalfunction(0.094, False)
]) ###### compute errors to simulate PIW uncertainty
tin = 0
ship_vel = 10.8 #m/s
mob_signal_time = 180 #seconds
distancetolkp = ship_vel * mob_signal_time
ax.set_facecolor('#e6f5ff')
locationuav = [50, 1000 + distancetolkp]
locationuav_no2 = [50, 1000 + distancetolkp]
start_point_uav = [50, 1000 + distancetolkp]
goals = 1
uavspeed = 15.0 #make sure that the loops align - search for "LOOP_PART" - there should be 3: 0, 1, 2 LOOP_PART0
sum_path = 0
theirgoal = 1
p = [0, 0]
piwlkp = [50, 1000]
locationstoplotplsnohate = []
piw_atmob = [
piwlkp[0] + downwind_leeway * (mob_signal_time) - errord * 2 *
(mob_signal_time), piwlkp[1]
]
center_piw_atmob = [
piwlkp[0] + downwind_leeway * (mob_signal_time), piwlkp[1]
]
timestamp = 10 #1 timestamp = 10 seconds
for i in range(
0, 2000,
timestamp): ##########Caution: TIMESTAMPS############## LOOP_PART1
t = i
timothy = (time.time() - person_down) #*10 + 100
ax = plt.gca()
ax.cla() # optionally clear axes
downwind_leeway, crosswind_leeway = leeway()
gg = 50 + downwind_leeway * t
op = 1000 + crosswind_leeway * t
exp1 = 0.12 * 2 * 2 * t #**2 #############EXPAND THE AREA every second##### on X
exp2 = 0.094 * 2 * 2 * t #**2 #### ON Y ####
theirupdown = 0
theirlist = []
thier_sum_path = 0
ells = Ellipse((gg, op), exp1, exp2, el_ang, color="#66c2ff")
plt.plot(gg, op, color='g', marker='o')
ells.set_alpha(0.4)
ells.set_clip_box(ax.bbox)
#ells.set_alpha(0.1)
ax.add_artist(ells)
if t >= mob_signal_time:
polygon1 = []
if foundline == False: ###FIND the intercept - where the UAV should fly to intersect with the last position where the PIW may be
for totot in range(t, 20000):
p = [
piw_atmob[0] + downwind_leeway *
(totot - mob_signal_time) - errord * 2 *
(totot - mob_signal_time), piw_atmob[1]
]
cant = dist(locationuav[0], locationuav[1], p[0], p[1])
auxil = p[0] - piw_atmob[0]
if int(
dist(locationuav[0], locationuav[1], p[0], p[1]) /
uavspeed) <= int(auxil /
(downwind_leeway - 2 * errord)):
firstone = totot - mob_signal_time
foundline = True
break
pathuav = []
pathuav.append([50, start_point_uav[1]])
pathuav.append(p)
plt.plot((50, p[0]), (start_point_uav[1], p[1]), 'b-')
plt.plot(piw_atmob[0], piw_atmob[1], color='m', marker='D')
plt.plot(p[0], p[1], color='m', marker='D')
if t <= mob_signal_time + int(
dist(start_point_uav[0], start_point_uav[1], p[0], p[1]) /
uavspeed):
errmm = (mob_signal_time + int(
dist(start_point_uav[0], start_point_uav[1], p[0], p[1]) /
uavspeed))
deliminator = 0.1
gg = 50 + downwind_leeway * errmm
op = 1000 + crosswind_leeway * errmm
exp1 = ((0.12) * 2) * 2 * errmm
exp2 = ((0.094) * 2) * 2 * errmm
####PLOT the search area####
ells = Ellipse((gg, op), exp1, exp2, el_ang, color="#ff0066")
plt.plot(gg, op, color='g', marker='o')
ells.set_alpha(0.3)
ells.set_clip_box(ax.bbox)
#ells.set_alpha(0.1)
ax.add_artist(ells)
if retursoph(
exp1, exp2, deliminator, gg, op
) not in soph: #merge search areas over different timestamps
soph.append(
retursoph(exp1, exp2, deliminator, gg,
op)) ####add polygons for each area(t)
xs, ys = [], []
for poop in range(0, len(soph[len(soph) - 1])):
xs.append(round(soph[len(soph) - 1][poop][0], 2))
ys.append(round(soph[len(soph) - 1][poop][1], 2))
polygon1 = shape_pol(
list(zip(xs, ys))
) ### polygon in shapely (library) format ### --- so that we can merge them
i += 1
else:
for i in range(
len(soph) + mob_signal_time + int(
dist(start_point_uav[0], start_point_uav[1], p[0],
p[1]) / uavspeed), t):
deliminator = 0.1
gg = 50 + downwind_leeway * i ###FIXED LEEWAY SPEED
op = 1000 + crosswind_leeway * i
exp1 = ((0.12) * 2) * 2 * i #**2
exp2 = (
(0.094) * 2
) * 2 * i ###############EXPAND THE search area #############
if i == t: ####PLOT the latest search area####
ells = Ellipse((gg, op),
exp1,
exp2,
el_ang,
color="#ff0066")
plt.plot(gg, op, color='g', marker='o')
ells.set_alpha(0.3)
ells.set_clip_box(ax.bbox)
#ells.set_alpha(0.1)
ax.add_artist(ells)
if i > 0:
if retursoph(exp1, exp2, deliminator, gg,
op) not in soph:
soph.append(
retursoph(
exp1, exp2, deliminator, gg,
op)) ####add polygons for each area(t)
xs, ys = [], []
for poop in range(0, len(soph[len(soph) - 1])):
xs.append(round(soph[len(soph) - 1][poop][0], 2))
ys.append(round(soph[len(soph) - 1][poop][1], 2))
polygon1 = shape_pol(
list(zip(xs, ys))
) ### polygon in shapely (library) format ### --- so that we can merge them
i += 1
if polygon1 != []: # > 0:
if elly == True: ####PUT POLYGONS TOGETHER
boundarii = cascaded_union([boundarii, polygon1])
else:
boundarii = cascaded_union([polygon1])
elly = True
patch2b = PolygonPatch(boundarii,
fc='#3399ff',
ec='#ff9900',
alpha=1,
zorder=2)
patch2b.set_alpha(0.3)
ax.add_patch(patch2b)
plt.grid(color='#ffcce0', linestyle=':', linewidth=2)
#####################STARTING TO PLOT THE PATH#######################################
boing = list(
boundarii.exterior.coords
) ###ASSIGN ALL POINTS IN FRAME POLYGON = list containing all points belonging to the polygon margins
murs = len(boing)
mid = boundarii.bounds[1] + (boundarii.bounds[3] -
boundarii.bounds[1]) / 2
upper = []
lower = []
########SORT ABOUT MID
for y in range(0, len(boing)):
if boing[y][1] > mid:
upper.append(boing[y])
#plt.plot(boing[y][0], boing[y][1], color = 'r', marker = 'o')
elif boing[y][1] <= mid:
lower.append(boing[y])
#plt.plot(boing[y][0], boing[y][1], color = 'b', marker = 'o')
#sort this??
lower = sorted(lower)
fov = 20
lolo = []
sum_path = 0
upup = []
########################### KEEP POINTS AT FOV DISTANCE ####################
lolo.append(lower[0])
for y in range(0, len(lower)):
keep = True
if y == 0:
auxx = 50 #
auxy = 1000
upper_x = 50 + downwind_leeway * t + (0.12) * 2 * t #**2
upper_y = 1000 + crosswind_leeway * t #+ (0.094)*t
else:
if dist(auxx, auxy, lower[y][0], lower[y][1]) > fov:
auxx = lower[y][0]
auxy = lower[y][1]
lolo.append(lower[y])
if dist(upper_x, upper_y, lower[y][0],
lower[y][1]) < fov - fov / 3:
break
upup.append(upper[0])
for y in range(0, len(upper)):
keep = True
if y == 0:
auxx = 50
auxy = 1000
upper_x = 50 + downwind_leeway * t + (0.12) * 2 * t #**2
upper_y = 1000 + crosswind_leeway * t #+ (0.094)*t
else:
if dist(auxx, auxy, upper[y][0], upper[y][1]) > fov:
auxx = upper[y][0]
auxy = upper[y][1]
if int(upper[y][0]) != 50 and int(upper[y][1]) != 50:
upup.append(upper[y])
if dist(upper_x, upper_y, upper[y][0],
upper[y][1]) < fov - fov / 3:
break
updown = 0
pathuav = []
pathuav.append([50, start_point_uav[1]])
pathuav.append(p)
pathuav.append([upup[0][0], upup[0][1]])
pathuav.append(
[upup[0][0], upup[0][1], 1000 + crosswind_leeway * 0])
sum_path += dist(upup[0][0], upup[0][1], 50, 1000)
upup.append([
50 + downwind_leeway * t + (0.12) * 2 * t,
1000 + crosswind_leeway * t
])
lolo.append([
50 + downwind_leeway * t + (0.12) * 2 * t,
1000 + crosswind_leeway * t
])
if len(lolo) < len(upup):
memes = len(lolo) - 1
else:
memes = len(upup) - 1
for mem in range(memes):
plt.plot((upup[mem][0], lolo[mem][0]),
(upup[mem][1], lolo[mem][1]), 'r-')
sum_path += dist(upup[mem][0], upup[mem][1], lolo[mem][0],
lolo[mem][1])
if updown == 0:
pathuav.append([upup[mem][0], upup[mem][1]])
pathuav.append([lolo[mem][0], lolo[mem][1]])
pathuav.append([lolo[mem + 1][0], lolo[mem + 1][1]])
updown = 1
sum_path += dist(lolo[mem + 1][0], lolo[mem + 1][1],
lolo[mem][0], lolo[mem][1])
else:
updown = 0
pathuav.append([lolo[mem][0], lolo[mem][1]])
pathuav.append([upup[mem][0], upup[mem][1]])
pathuav.append([upup[mem + 1][0], upup[mem + 1][1]])
ey = 0
for point in pathuav:
if ey < len(pathuav) - 1:
plt.plot((pathuav[ey + 1][0], pathuav[ey][0]),
(pathuav[ey + 1][1], pathuav[ey][1]),
color='#339966',
marker='_')
ey += 1
if t >= mob_signal_time:
for i in range(int(uavspeed) * timestamp +
1): ######## LOOP_PART2
if goals < len(pathuav):
p1 = locationuav
p2 = pathuav[goals]
x = p2[0] - p1[0]
y = p2[1] - p1[1]
#print (x, y)
angle = math.atan2(y, x)
locationuav = [p1[0] + cos(angle), p1[1] + sin(angle)]
if int(pathuav[goals][0]) in np.arange(
int(locationuav[0]) - 2.0,
int(locationuav[0]) + 2.0) and int(
pathuav[goals][1]) in np.arange(
int(locationuav[1]) - 2.0,
int(locationuav[1]) + 2.0):
goals += 1
plt.plot(locationuav[0],
locationuav[1],
color='k',
marker='o') #339966
if cleo == False:
for point in listpiw:
if point[0] < locationuav[
0] + fov / 2 and point[
0] > locationuav[0] - fov / 2:
if point[1] < locationuav[
1] + fov / 2 and point[
1] > locationuav[1] - fov / 2:
print('seen')
listpiw.remove(point)
# ################ PIW ################
if cleo and t == 0: ###########GENERATE POINTS, only once
ggp = 50 + downwind_leeway * 1 ###FIXED LEEWAY SPEED
opp = 1000 + crosswind_leeway * 1
exp1p = ((0.12) * 2) * t #**2
exp2p = ((0.094) * 2) * t
listpiw = genpoint(gg, op, exp1p, exp2p, el_ang, errors, t)
cleo = False
print('points generated')
for point in listpiw:
plt.plot(point[0], point[1], color='r', marker='o')
###################MOVE POINTS #########################
elif t > 0: #and tin < t:
dancing = 0
freeze = 0
comprised = 0
for point in range(len(listpiw)):
if point / 2.0 == 0:
insteadofcrosswind_leeway = 0.1
else:
insteadofcrosswind_leeway = -0.1
add = piw_movement(listpiw[point][0], listpiw[point][1],
downwind_leeway * (t - tin),
crosswind_leeway * (t - tin),
t) #HOLD INITIAL POSITION OF POINT
listpiw[point][0] += add[0] + errors[point][0] * (
t - tin
) ## set list of errors created before the while loop ##
listpiw[point][1] += add[1] + errors[point][1] * (t - tin)
freeze, dancing = insidecheck(
listpiw[point][0], listpiw[point][1], gg, op, exp1, exp2,
el_ang, freeze,
dancing) #Display PIWs: red = not within the search area
tin = t
prev_t = t
if goals > 1 or t < mob_signal_time:
plt.axis([0, 1000, 700, 1300])
else:
plt.axis([0, 1000, 700, 1100 + ship_vel * mob_signal_time])
ax.set_xlabel((t, str('s'), 'PIW spawned', 200, 'PIW remaining',
len(listpiw), 'UAV takeoff (s)', mob_signal_time,
'PIW speed (cm/s)', round(downwind_leeway, 2)),
fontsize=14)
plt.draw()
plt.pause(0.1)
plt.show()
time.sleep(1)
def plot_patch(self,
xc,
yc,
patch_size,
scale=1,
magn_base=4,
translate=True,
colordict={},
figsize=None,
vis_scale=True,
fig=None,
ax=None,
alpha=0.1,
**kwargs):
if 'target_subsample' in kwargs:
scale = kwargs.pop('target_subsample')
warn('deprication warning', DeprecationWarning)
if isinstance(patch_size, int) or isinstance(patch_size, float):
patch_size = [int(patch_size)] * 2
patch = self.get_patch(
xc,
yc,
patch_size,
scale=scale,
magn_base=magn_base,
)
prois = self.get_patch_rois(xc,
yc,
patch_size,
scale=scale,
translate=translate)
if fig is None:
if ax is not None:
fig = ax.get_figure()
else:
if len(kwargs) > 0 or figsize is not None:
fig, ax = plt.subplots(1, figsize=figsize, **kwargs)
else:
fig = plt.gcf()
ax = fig.gca()
elif ax is None:
ax = fig.gca()
ccycle = plt.rcParams['axes.prop_cycle'].by_key()['color']
ccycle = cycle(ccycle)
out_patch_size = patch_size
if scale != 1:
if vis_scale:
out_patch_size = [
int(np.round(ps / scale)) for ps in patch_size
]
scale_ = lambda x: x
else:
def scale_(x):
origin = (0, 0) if translate else (xc, yc)
return affinity.scale(x, scale, scale, origin=origin)
print('out_patch_size', out_patch_size)
if translate:
extent = (0, out_patch_size[0], out_patch_size[1], 0)
else:
extent = (
xc - out_patch_size[0] // 2,
xc + out_patch_size[0] // 2,
yc + out_patch_size[1] // 2,
yc - out_patch_size[1] // 2,
)
print('extent', extent)
ax.imshow(patch, extent=extent)
for name_, gg in prois.groupby('name'):
flag = True
if name_ in colordict:
c = colordict[name_]
else:
c = next(ccycle)
for _, pp_ in gg.iterrows():
#print(pp_['name'])
pp = pp_.polygon
if scale != 1:
pp = scale_(pp)
fc = list(colors.to_rgba(c))
ec = list(colors.to_rgba(c))
fc[-1] = alpha
ax.add_patch(
PolygonPatch(pp,
fc=fc,
ec=ec,
lw=2,
label=name_ if flag else None))
flag = False
ax.relim()
ax.autoscale_view()
return fig, ax, patch, prois
def plotBlocksForRedistrictingGroups(redistrictingGroups,
showPopulationCounts=False,
showBlockGraphIds=False,
showDistrictNeighborConnections=False,
showBlockNeighborConnections=False,
showGraphHeatmap=False,
showGeometryPoints=False):
fig = pyplot.figure(figsize=(8, 8))
ax = fig.gca()
for redistrictingGroup in redistrictingGroups:
if showDistrictNeighborConnections:
for neighborGroup in redistrictingGroup.allNeighbors:
if neighborGroup in redistrictingGroups:
ax.add_line(
getLineForPair(redistrictingGroup, neighborGroup,
grayColor))
if showGeometryPoints:
centroid = redistrictingGroup.geometry.centroid
ax.scatter(centroid.x, centroid.y)
maxPopulationEnergy = max(
[block.populationEnergy for block in redistrictingGroup.children])
heatMap = cm.get_cmap('hot')
heatmapNormalizer = colors.Normalize(vmin=0.0,
vmax=maxPopulationEnergy)
for block in redistrictingGroup.children:
if block.isWater:
ax.add_patch(
PolygonPatch(block.geometry,
fc=blueColor,
ec=blueColor,
alpha=0.5,
zorder=2))
else:
if showGraphHeatmap:
normalizedEnergy = heatmapNormalizer(
block.populationEnergy)
heatColor = heatMap(normalizedEnergy)
ax.add_patch(
PolygonPatch(block.geometry,
fc=heatColor,
ec=heatColor,
alpha=0.5,
zorder=2))
else:
if redistrictingGroup.isBorderBlock(block):
if block in redistrictingGroup.northernChildBlocks:
borderBlockColor = purpleColor
elif block in redistrictingGroup.westernChildBlocks:
borderBlockColor = yellowColor
elif block in redistrictingGroup.southernChildBlocks:
borderBlockColor = orangeColor
else:
borderBlockColor = turquoiseColor
ax.add_patch(
PolygonPatch(block.geometry,
fc=borderBlockColor,
ec=borderBlockColor,
alpha=0.5,
zorder=2))
else:
ax.add_patch(
PolygonPatch(block.geometry,
fc=greenColor,
ec=greenColor,
alpha=0.5,
zorder=2))
centerOfBlock = block.geometry.centroid
if showPopulationCounts:
ax.text(x=centerOfBlock.x,
y=centerOfBlock.y,
s=block.population,
fontdict=font)
if showBlockGraphIds:
ax.text(x=centerOfBlock.x,
y=centerOfBlock.y,
s=block.graphId,
fontdict=font)
if showBlockNeighborConnections:
for neighborBlock in block.allNeighbors:
ax.add_line(getLineForPair(block, neighborBlock,
grayColor))
ax.axis('scaled')
pyplot.show()
from matplotlib import pyplot
from shapely.geometry import Point
from descartes import PolygonPatch
import sys
BLUE = "#6699cc"
GRAY = "#cecece"
SIZE = 10, 10
fig = pyplot.figure(1, figsize=SIZE, dpi=90)
ax = fig.add_subplot(111)
fin = open(sys.argv[1], 'r')
for line in fin:
args = line.split(";")
pt = Point(float(args[0]), float(args[1])).buffer(float(sys.argv[2]))
patch = PolygonPatch(pt, fc=GRAY, ec=GRAY, alpha=0.7, zorder=1)
ax.add_patch(patch)
# 1
xrange = [-10, 100]
yrange = [-10, 100]
ax.set_xlim(*xrange)
ax.set_xticks(range(*xrange) + [xrange[-1]])
ax.set_ylim(*yrange)
ax.set_yticks(range(*yrange) + [yrange[-1]])
ax.set_aspect(1)
pyplot.show()
with open("geonames_pop.txt",'r') as f2:
pop_str = f2.read()
cty_polygons = json.loads(cty_str)
places_pts = json.loads(pop_str)
counties = shape_maker(cty_polygons)
towns = shape_maker(places_pts)
cty_features = []
for cf in counties['features']:
cty_features.append(cf)
patches = []
for cf in cty_features:
if cf.geom_type == 'Polygon':
patches.append(PolygonPatch(cf))
elif cf.geom_type == 'MultiPolygon':
for poly in cf:
patches.append(PolygonPatch(poly))
for patch in patches:
fig = plt.figure()
ax = fig.add_subplot(111)
m = Basemap(llcrnrlon=-11.5,llcrnrlat=51.0,urcrnrlon=-5.0,urcrnrlat=56.0,
resolution='i',projection='tmerc',lon_0=-7.36,lat_0=53.0, epsg = 29902)
ax.add_patch(patch)
plt.show()
def _run(input_outlook_file_name, input_warning_file_name, border_colour,
warning_colour, min_plot_latitude_deg, max_plot_latitude_deg,
min_plot_longitude_deg, max_plot_longitude_deg, output_file_name):
"""Plots SPC convective outlook.
This is effectively the main method.
:param input_outlook_file_name: See documentation at top of file.
:param input_warning_file_name: Same.
:param border_colour: Same.
:param warning_colour: Same.
:param min_plot_latitude_deg: Same.
:param max_plot_latitude_deg: Same.
:param min_plot_longitude_deg: Same.
:param max_plot_longitude_deg: Same.
:param output_file_name: Same.
"""
print(
'Reading SPC outlook from: "{0:s}"...'.format(input_outlook_file_name))
pickle_file_handle = open(input_outlook_file_name, 'rb')
outlook_table = pickle.load(pickle_file_handle)
pickle_file_handle.close()
risk_type_enums = numpy.array([
RISK_TYPE_STRING_TO_ENUM[s]
for s in outlook_table[RISK_TYPE_COLUMN].values
],
dtype=int)
sort_indices = numpy.argsort(risk_type_enums)
outlook_table = outlook_table.iloc[sort_indices]
outlook_table = _get_bounding_boxes(outlook_table)
if input_warning_file_name in ['', 'None']:
warning_table = None
else:
print('Reading tornado warnings from: "{0:s}"...'.format(
input_warning_file_name))
pickle_file_handle = open(input_warning_file_name, 'rb')
warning_table = pickle.load(pickle_file_handle)
pickle_file_handle.close()
warning_table = _get_bounding_boxes(warning_table)
latitude_limits_deg, longitude_limits_deg = _get_plotting_limits(
min_plot_latitude_deg=min_plot_latitude_deg,
max_plot_latitude_deg=max_plot_latitude_deg,
min_plot_longitude_deg=min_plot_longitude_deg,
max_plot_longitude_deg=max_plot_longitude_deg,
outlook_table=outlook_table,
warning_table=warning_table)
min_plot_latitude_deg = latitude_limits_deg[0]
max_plot_latitude_deg = latitude_limits_deg[1]
min_plot_longitude_deg = longitude_limits_deg[0]
max_plot_longitude_deg = longitude_limits_deg[1]
print(('Plotting limits = [{0:.2f}, {1:.2f}] deg N and [{2:.2f}, {3:.2f}] '
'deg E').format(min_plot_latitude_deg, max_plot_latitude_deg,
min_plot_longitude_deg, max_plot_longitude_deg))
latlng_limit_dict = {
plotting_utils.MIN_LATITUDE_KEY: min_plot_latitude_deg,
plotting_utils.MAX_LATITUDE_KEY: max_plot_latitude_deg,
plotting_utils.MIN_LONGITUDE_KEY: min_plot_longitude_deg,
plotting_utils.MAX_LONGITUDE_KEY: max_plot_longitude_deg
}
axes_object, basemap_object = plotting_utils.create_map_with_nwp_proj(
model_name=nwp_model_utils.RAP_MODEL_NAME,
grid_name=nwp_model_utils.NAME_OF_130GRID,
xy_limit_dict=None,
latlng_limit_dict=latlng_limit_dict,
resolution_string='i')[1:]
plotting_utils.plot_coastlines(basemap_object=basemap_object,
axes_object=axes_object,
line_colour=border_colour)
plotting_utils.plot_countries(basemap_object=basemap_object,
axes_object=axes_object,
line_colour=border_colour)
plotting_utils.plot_states_and_provinces(basemap_object=basemap_object,
axes_object=axes_object,
line_colour=border_colour)
_, unique_risk_type_indices = numpy.unique(
outlook_table[RISK_TYPE_COLUMN].values, return_index=True)
num_outlooks = len(outlook_table.index)
legend_handles = []
legend_strings = []
for i in range(num_outlooks):
this_risk_type_string = outlook_table[RISK_TYPE_COLUMN].values[i]
this_colour = RISK_TYPE_STRING_TO_COLOUR[this_risk_type_string]
this_vertex_dict_latlng = polygons.polygon_object_to_vertex_arrays(
outlook_table[POLYGON_COLUMN].values[i])
these_x_coords_metres, these_y_coords_metres = basemap_object(
this_vertex_dict_latlng[polygons.EXTERIOR_X_COLUMN],
this_vertex_dict_latlng[polygons.EXTERIOR_Y_COLUMN])
this_polygon_object_xy = polygons.vertex_arrays_to_polygon_object(
exterior_x_coords=these_x_coords_metres,
exterior_y_coords=these_y_coords_metres)
this_patch_object = PolygonPatch(this_polygon_object_xy,
lw=0.,
ec=this_colour,
fc=this_colour,
alpha=OUTLOOK_OPACITY)
this_handle = axes_object.add_patch(this_patch_object)
if i in unique_risk_type_indices:
this_string = '{0:s}{1:s}'.format(this_risk_type_string[0].upper(),
this_risk_type_string[1:])
legend_strings.append(this_string)
legend_handles.append(this_handle)
if warning_table is None:
num_warnings = 0
else:
num_warnings = len(warning_table.index)
warning_colour_tuple = plotting_utils.colour_from_numpy_to_tuple(
warning_colour)
for i in range(num_warnings):
this_vertex_dict_latlng = polygons.polygon_object_to_vertex_arrays(
warning_table[POLYGON_COLUMN].values[i])
these_x_coords_metres, these_y_coords_metres = basemap_object(
this_vertex_dict_latlng[polygons.EXTERIOR_X_COLUMN],
this_vertex_dict_latlng[polygons.EXTERIOR_Y_COLUMN])
axes_object.plot(these_x_coords_metres,
these_y_coords_metres,
color=warning_colour_tuple,
linestyle='solid',
linewidth=WARNING_LINE_WIDTH)
axes_object.legend(legend_handles, legend_strings, loc='upper left')
print('Saving figure to: "{0:s}"...'.format(output_file_name))
file_system_utils.mkdir_recursive_if_necessary(file_name=output_file_name)
pyplot.savefig(output_file_name, dpi=FIGURE_RESOLUTION_DPI)
pyplot.close()
imagemagick_utils.trim_whitespace(input_file_name=output_file_name,
output_file_name=output_file_name)
def plot_buildings(gdf,
fig=None,
ax=None,
figsize=None,
color='#333333',
bgcolor='w',
set_bounds=True,
bbox=None,
save=False,
show=True,
close=False,
filename='image',
file_format='png',
dpi=600):
"""
Plot a GeoDataFrame of building footprints.
Parameters
----------
gdf : GeoDataFrame
building footprints
fig : figure
ax : axis
figsize : tuple
color : string
the color of the building footprints
bgcolor : string
the background color of the plot
set_bounds : bool
if True, set bounds from either passed-in bbox or the spatial extent of
the gdf
bbox : tuple
if True and if set_bounds is True, set the display bounds to this bbox
save : bool
whether to save the figure to disk or not
show : bool
whether to display the figure or not
close : bool
close the figure (only if show equals False) to prevent display
filename : string
the name of the file to save
file_format : string
the format of the file to save (e.g., 'jpg', 'png', 'svg')
dpi : int
the resolution of the image file if saving
Returns
-------
GeoDataFrame
"""
if fig is None or ax is None:
fig, ax = plt.subplots(figsize=figsize, facecolor=bgcolor)
ax.set_facecolor(bgcolor)
# extract each polygon as a descartes patch, and add to a matplotlib patch
# collection
patches = []
for geometry in gdf['geometry']:
if isinstance(geometry, Polygon):
patches.append(PolygonPatch(geometry))
elif isinstance(geometry, MultiPolygon):
for subpolygon in geometry: #if geometry is multipolygon, go through each constituent subpolygon
patches.append(PolygonPatch(subpolygon))
pc = PatchCollection(patches,
facecolor=color,
edgecolor=color,
linewidth=0,
alpha=1)
ax.add_collection(pc)
if set_bounds:
if bbox is None:
# set the figure bounds to the polygons' bounds
left, bottom, right, top = gdf.total_bounds
else:
top, bottom, right, left = bbox
ax.set_xlim((left, right))
ax.set_ylim((bottom, top))
# turn off the axis display set the margins to zero and point the ticks in
# so there's no space around the plot
ax.axis('off')
ax.margins(0)
ax.tick_params(which='both', direction='in')
fig.canvas.draw()
# make everything square
ax.set_aspect('equal')
fig.canvas.draw()
fig, ax = save_and_show(fig=fig,
ax=ax,
save=save,
show=show,
close=close,
filename=filename,
file_format=file_format,
dpi=dpi,
axis_off=True)
return fig, ax
def _plot_kriged_cps(args,
fig_size,
bck_polys_list,
krige_x_coords_mesh,
krige_y_coords_mesh,
anom_type,
cont_levels,
out_figs_dir,
x_coords,
y_coords,
best_cps_min_anoms,
best_cps_max_anoms,
best_cps_std_anoms,
msgs):
(cp_nos,
krige_z_coords_mesh,
cp_x_coords_list,
cp_y_coords_list,
vgs_list,
cp_rules_arr) = args
max_n_coords = 10
n_x_coords = x_coords.shape[0]
n_y_coords = y_coords.shape[0]
x_ticks_pos = np.arange(0, n_x_coords)
y_ticks_pos = np.arange(0, n_y_coords)
if n_x_coords > max_n_coords:
x_step_size = n_x_coords // max_n_coords
else:
x_step_size = 1
if n_y_coords > max_n_coords:
y_step_size = n_y_coords // max_n_coords
else:
y_step_size = 1
cmap = plt.get_cmap('autumn')
min_cbar_val = min(best_cps_min_anoms.min(),
best_cps_max_anoms.min())
max_cbar_val = max(best_cps_min_anoms.max(),
best_cps_max_anoms.max())
# CP
cps_fig = plt.figure(figsize=fig_size)
cps_ax = cps_fig.gca()
cp_std_fig = plt.figure(figsize=fig_size)
cp_std_ax = cp_std_fig.gca()
for j, cp_no in enumerate(range(cp_nos[0], cp_nos[1])):
if msgs:
print('Plotting CP No.', cp_no)
plt.figure(cps_fig.number)
if bck_polys_list is not None:
for poly in bck_polys_list:
cps_ax.add_patch(PolygonPatch(poly,
alpha=0.5,
fc='#999999',
ec='#999999'))
cs = cps_ax.contour(krige_x_coords_mesh,
krige_y_coords_mesh,
krige_z_coords_mesh[j],
levels=cont_levels,
vmin=0.0,
vmax=1.0,
linestyles='solid',
extend='both')
if anom_type != 'd':
cps_ax.scatter(cp_x_coords_list[j], cp_y_coords_list[j])
cps_ax.set_title('CP no. %d, %s' % (cp_no, vgs_list[j]))
cps_ax.set_xlim(krige_x_coords_mesh.min(),
krige_x_coords_mesh.max())
cps_ax.set_ylim(krige_y_coords_mesh.min(),
krige_y_coords_mesh.max())
cps_ax.set_xlabel('Eastings')
cps_ax.set_ylabel('Northings')
cps_ax.clabel(cs, inline=True, inline_spacing=0.01, fontsize=10)
plt.savefig(str(out_figs_dir / ('cp_map_%0.2d.png' % (cp_no))),
bbox_inches='tight')
cps_ax.cla()
# CP Std.
plt.figure(cp_std_fig.number)
cax = cp_std_ax.imshow(best_cps_std_anoms[cp_no],
origin='upper',
interpolation=None,
cmap=cmap)
if anom_type != 'd':
_cp_rules_str = (
cp_rules_arr[j].reshape(
best_cps_std_anoms[cp_no].shape).astype('|U'))
txt_x_corrs = np.tile(range(_cp_rules_str.shape[1]),
_cp_rules_str.shape[0])
txt_y_corrs = np.repeat(range(_cp_rules_str.shape[0]),
_cp_rules_str.shape[1])
for k in range(txt_x_corrs.shape[0]):
cp_std_ax.text(txt_x_corrs[k],
txt_y_corrs[k],
_cp_rules_str[txt_y_corrs[k],
txt_x_corrs[k]],
va='center',
ha='center',
color='black')
cp_std_ax.set_xticks(x_ticks_pos[::x_step_size])
cp_std_ax.set_yticks(y_ticks_pos[::y_step_size])
cp_std_ax.set_xticklabels(x_coords[::x_step_size])
cp_std_ax.set_yticklabels(y_coords[::y_step_size])
cp_std_ax.set_xlabel('Eastings')
cp_std_ax.set_ylabel('Northings')
cbar = cp_std_fig.colorbar(cax, orientation='horizontal')
cbar.set_label('Anomaly Std.')
cp_std_ax.set_title('Std. CP no. %d' % (cp_no))
plt.savefig(str(out_figs_dir / ('std_cp_map_%0.2d.png' % (cp_no))),
bbox_inches='tight')
cbar.remove()
cp_std_ax.cla()
# CP Min. and Max.
cp_min_max_fig = plt.figure(figsize=fig_size)
cp_min_max_grid = gridspec.GridSpec(1, 2)
cp_min_ax = plt.subplot(cp_min_max_grid[0, 0])
cp_max_ax = plt.subplot(cp_min_max_grid[0, 1])
plt.figure(cp_min_max_fig.number)
# Min
cax_min = cp_min_ax.imshow(best_cps_min_anoms[cp_no],
origin='upper',
interpolation=None,
vmin=min_cbar_val,
vmax=max_cbar_val,
cmap=cmap)
cp_min_ax.set_xticks(x_ticks_pos[::x_step_size])
cp_min_ax.set_yticks(y_ticks_pos[::y_step_size])
cp_min_ax.set_xticklabels(x_coords[::x_step_size])
cp_min_ax.set_yticklabels(y_coords[::y_step_size])
cp_min_ax.set_xlabel('Eastings')
cp_min_ax.set_ylabel('Northings')
cp_min_ax.set_title('Min. Anomaly CP no. %d' % (cp_no))
# Max
cp_max_ax.imshow(best_cps_max_anoms[cp_no],
origin='upper',
interpolation=None,
vmin=min_cbar_val,
vmax=max_cbar_val,
cmap=cmap)
cp_max_ax.set_xticks(x_ticks_pos[::x_step_size])
cp_max_ax.set_yticks(y_ticks_pos[::y_step_size])
cp_max_ax.set_xticklabels(x_coords[::x_step_size])
cp_max_ax.set_yticklabels([])
cp_max_ax.set_xlabel('Eastings')
cbar = cp_min_max_fig.colorbar(cax_min,
ax=[cp_min_ax, cp_max_ax],
orientation='horizontal')
cp_max_ax.set_title('Max. Anomaly CP no. %d' % (cp_no))
plt.savefig(str(out_figs_dir /
('min_max_cp_map_%0.2d.png' % (cp_no))),
bbox_inches='tight')
plt.close()
plt.close('all')
return
# SEPARAR EM SLICES NO EIXO X COM INTERVALOR DE 1000
intervalo= 1000 # se ficar menor não fecha o polígono
total = 0
voltotal=0
for i in range(len(dados_x)//intervalo):
points = [(y,z) for y,z in zip(dados_y[i*intervalo: (i+1)*intervalo],dados_z[i*intervalo: (i+1)*intervalo])]
# DEFININDO ALPHA
alpha_shape = alphashape.alphashape(points,0.)
# alpha_shape = alphashape.alphashape(points) # calculo do alpha automatico
fig, ax = plt.subplots()
ax.scatter(*zip(*points))
ax.add_patch(PolygonPatch(alpha_shape, alpha=0.2)) #0,2
# Plotar arquivo .txt de cada slice
# fig.savefig(root+'selecao_teste/fig_{}.png'.format(i))
print(i)
points_slice = [(x,y,z) for x,y,z in zip(dados_x[i*intervalo: (i+1)*intervalo],dados_y[i*intervalo: (i+1)*intervalo],dados_z[i*intervalo: (i+1)*intervalo])]
plt.close(fig)
#plt.close(allfig)
dados_df2= np.array(points_slice)[:,:3] # ajustar arquivo txt - (linha , coluna)
dados2 = dados_df2[dados_df2[:,0].argsort()] #ordenar eixo x
dados_x2= dados2[:,0]
dados_y2= dados2[:,1]
dados_z2= dados2[:,2]
def make_collection(self, shp, index_field=None,
s=20, fc='0.8', ec='k', lw=0.5, alpha=0.5,
color_field=None,
cbar=False, clim=(), cmap='jet', cbar_label=None,
simplify_patches=100,
zorder=5,
convert_coordinates=1,
remove_offset=True,
collection_name=None,
**kwargs):
if collection_name is None:
collection_name = os.path.split(shp)[-1].split('.')[0]
df = shp2df(shp)
if index_field is not None:
df.index = df[index_field]
proj4 = get_proj4(shp)
if proj4 != self.proj4:
df['geometry'] = projectdf(df, proj4, self.proj4)
# convert projected coordinate units and/or get rid z values if the shapefile has them
if convert_coordinates != 1 or df.iloc[0]['geometry'].has_z:
df['geometry'] = [transform(lambda x, y, z=None: (x * convert_coordinates,
y * convert_coordinates), g)
for g in df.geometry]
# remove model offset from projected coordinates (llcorner = 0,0)
if remove_offset:
df['geometry'] = [translate(g,
-1 * self.extent_proj[0],
-1 * self.extent_proj[1]) for g in df.geometry]
if simplify_patches > 0:
df['geometry'] = [g.simplify(simplify_patches) for g in df.geometry]
if 'Polygon' in df.iloc[0].geometry.type:
print "building PatchCollection..."
inds = []
patches = []
for i, g in df.geometry.iteritems():
if g.type != 'MultiPolygon':
inds.append(i)
patches.append(PolygonPatch(g))
else:
for part in g.geoms:
inds.append(i)
patches.append(PolygonPatch(part))
collection = PatchCollection(patches, cmap=cmap,
facecolor=fc, linewidth=lw, edgecolor=ec, alpha=alpha,
)
elif 'LineString' in df.geometry[0].type:
print "building LineCollection..."
inds = []
lines = []
for i, g in df.geometry.iteritems():
if 'Multi' not in g.type:
x, y = g.xy
inds.append(i)
lines.append(zip(x, y))
# plot each line in a multilinestring
else:
for l in g:
x, y = l.xy
inds.append(i)
lines.append(zip(x, y))
collection = LineCollection(lines, colors=ec, linewidths=lw, alpha=alpha, zorder=zorder, **kwargs)
#lc.set_edgecolor(ec)
#lc.set_alpha(alpha)
#lc.set_lw(lw)
# set the color scheme (could set line thickness by same proceedure)
if fc in df.columns:
colors = np.array([df[fc][ind] for ind in inds])
collection.set_array(colors)
else:
print "plotting points..."
x = np.array([g.x for g in df.geometry])
y = np.array([g.y for g in df.geometry])
collection = self.ax.scatter(x, y, s=s, c=fc, ec=ec, lw=lw, alpha=alpha, zorder=zorder, **kwargs)
inds = range(len(x))
self.layers[collection_name] = df
self.collections[collection_name] = collection
self.collection_inds[collection_name] = inds
return collection
init_t = math.atan(2.5)
r = math.sqrt(10**2 + 25**2)
thetas = [init_t, math.pi - init_t, math.pi + init_t, 2 * math.pi - init_t]
def gen_rect_pts(x, y, alpha):
return [(x + r * math.cos(theta + alpha), y + r * math.sin(theta + alpha))
for theta in thetas]
fig, ax = plt.subplots()
plt.ion()
plt.show()
for pt in [(-50, -50), (-50, 50), (50, 50), (50, -50)]:
ax.plot(*pt)
ax.autoscale_view()
plt.draw()
plt.pause(0.1)
i = 0.
while i <= 2 * math.pi:
print(math.degrees(i + init_t),
["(%.2f,%.2f)" % pt for pt in gen_rect_pts(10, 25, i)])
ax.add_patch(PolygonPatch(Polygon(gen_rect_pts(10, 25, i))))
i += math.pi / 64
plt.draw()
plt.pause(0.01)
plt.ioff()
plt.show()
def plot(self, ax):
patch = PolygonPatch(self.getShape())
ax.add_patch(patch)