def polygon_subplots(polys, names=None, columns=2, figsize=(12, 24), dpi=300):
if names is None:
names = range(len(polys))
colors = colormap.rescale_and_interpolate(colormap.turbo_colormap_data,
range(0, len(polys)))
fig = plt.figure(figsize=figsize, dpi=dpi)
rows = len(polys) // columns
if len(polys) % columns != 0:
rows += 1
for i, (poly, name, color) in enumerate(zip(polys, names, colors)):
try:
ax = fig.add_subplot(rows, columns, i + 1)
ax.axis("equal")
ax.add_patch(PolygonPatch(poly, facecolor=color, linewidth=0.1))
ax.autoscale()
ax.set_title(name)
ax.set_xticks([])
ax.set_yticks([])
except ValueError as e:
continue
plt.show()
def plotOne(step):
fig = plt.figure(figsize=(6, 8))
ax1 = plt.subplot2grid((4, 3), (0, 0), rowspan=3, colspan=3)
ax2 = plt.subplot2grid((4, 3), (3, 0), colspan=3)
for ii, particle in enumerate(box.particleSteps[step]):
topcolor = "blue"
pt = Point(particle[2], particle[3]).buffer(particle[1], cap_style=1)
patch = PolygonPatch(pt, fc=topcolor)
ax1.add_patch(patch)
ax1.set_ylim([0, height])
ax1.set_xlim([0, width])
# plot histogram of speeds
speeds = [x[4] for x in box.particleSteps[step]]
bins = numpy.linspace(0, 3 * v, 50)
ax2.hist(speeds, bins=bins)
ax2.set_xlim([0, 3 * v])
# ax2.set_ylim([0, nParticles*1.1])
ax2.set_xlabel("velocity")
plt.savefig("step_%08d.png" % step, dpi=150)
plt.close()
def disegna_stanze(stanze, colori, xmin, ymin, xmax, ymax,savefig = True, format='pdf', filepath = '.', savename = '8_Stanze', title = False):
'''
disegna il layout delle stanze.
'''
fig, ax = setup_plot()
savename = os.path.join(filepath, savename+'.'+format)
#plt.subplot(224)
if title :
ax.set_title('7.stanze')
for index,s in enumerate(stanze):
f_patch = PolygonPatch(s,fc=colori[index],ec='BLACK')
ax.add_patch(f_patch)
ax.set_xlim(xmin,xmax)
ax.set_ylim(ymin,ymax)
if savefig :
plt.savefig(savename,bbox_inches='tight')
else :
plt.show()
return (fig, ax)
def draw_concave_hull(cls, xy): #pts = [xy[vertice] for vertice in spatial.ConvexHull(xy).vertices] #pts = [xy[vertice] for vertice in alphashape.alphashape(xy, 2).vertices] # alpha-parameter can be removed to reoptimize alpha #print(optimizealpha(xy, max_iterations=100000)) #pts = alphashape(xy, 2.2) print(len(xy)) pts = alphashape(xy, 4.235604062127975e-05) #pts = alphashape(xy, 7.235604062127975e-06) #pts = alphashape(xy, 7.235604062127975e-06) #pts = alphashape(xy, 1.9846167135906253e-05) #pts = alphashape.alphashape(xy, 2) # add 10 km buffer zone for error plt.gca().add_patch( PolygonPatch( pts.buffer(10000), color='#de9752', alpha=0.5, zorder=3, transform=ccrs.epsg(3067)))
def _plot_gdf(self, gdf, kwargs={}, ax=None):
"""
Plot geodataframe to axis
This function will plot a default style for all geometry types.
Paramaters
----------
gdf : geopandas.GeoDataFrame
geodataframe with data to plot
kwargs : dictionary
dictionary with keyword arguments for plotting
ax : matplotlib.pyplot.axes
axes to plot to
"""
if ax is None:
ax = self.ax
# get geometries
if isinstance(gdf, gpd.GeoSeries):
geometries = [gdf['geometry']]
else:
geometries = gdf['geometry'].values.tolist()
# for line and pts
if isinstance(geometries[0], LineString):
# Create collection
segments = [np.vstack(geo.coords[:]) for geo in geometries]
collection = ax.add_collection(LineCollection(segments, **kwargs))
if isinstance(geometries[0], Polygon):
# Create collection
polygons = [PolygonPatch(geo) for geo in geometries]
collection = ax.add_collection(PatchCollection(polygons, **kwargs))
if isinstance(geometries[0], Point):
kwargs['linestyle'] = ''
crds = np.vstack([pt.coords[0] for pt in geometries])
collection, = ax.plot(*crds.T, **kwargs)
return collection
def get_patches(self,
origin=(0, 0),
angle_sum=0,
angle=0,
layers: Optional[List[int]] = None):
from descartes import PolygonPatch
def rotate_pos(pos, rotation_angle):
if rotation_angle is None:
return pos
c, s = np.cos(rotation_angle), np.sin(rotation_angle)
result = np.array([[c, -s], [s, c]]).dot(pos)
return result
own_patches = []
for layer, geometry in self.layer_dict.items():
if layers is not None and layer not in layers:
continue
geometry = geometric_union(geometry)
if geometry.is_empty:
continue
geometry = translate(
rotate(geometry, angle_sum, use_radians=True, origin=(0, 0)),
*origin)
own_patches.append(
PolygonPatch(geometry,
color=['red', 'green', 'blue', 'teal',
'pink'][(layer - 1) % 5],
linewidth=0))
sub_cells_patches = [
p for cell_dict in self.cells
for p in cell_dict['cell'].get_patches(
np.array(origin) + rotate_pos(cell_dict['origin'], angle),
angle_sum=angle_sum + (cell_dict['angle'] or 0),
angle=cell_dict['angle'],
layers=layers)
]
return own_patches + sub_cells_patches
def plot_polygon(rec, ax=None, **kwargs):
"""method to plot the polygon intersection results from
the resulting numpy.recarray.
Note: only works when recarray has 'intersects' column!
Parameters
----------
rec : numpy.recarray
record array containing intersection results
(the resulting shapes)
ax : matplotlib.pyplot.axes, optional
axes to plot onto, if not provided, creates a new figure
**kwargs:
passed to the plot function
Returns
-------
ax: matplotlib.pyplot.axes
returns the axes handle
"""
try:
import matplotlib.pyplot as plt
except ImportError:
print('This feature requires matplotlib.')
try:
from descartes import PolygonPatch
except ModuleNotFoundError:
raise ModuleNotFoundError(
"descartes module needed for plotting polygons")
if ax is None:
_, ax = plt.subplots()
for i, ishp in enumerate(rec.ixshapes):
ppi = PolygonPatch(ishp, facecolor="C{}".format(i % 10), **kwargs)
ax.add_patch(ppi)
return ax
def plot_mover(hallway, hallway_set, theta, N, i, hway_num, smooth=True):
plt.cla() #clear axis in the case it had already been opened
if smooth == True:
try:
carver = get_carver(hallway_set)
print("smoothing rotation path")
hallway = hallway.difference(carver)
except:
print("failed to carve")
mp = round(len(hallway_set) / 2)
minx, miny, maxx, maxy = hallway.bounds
plt.style.use('ggplot')
fig = plt.figure(dpi=200, figsize=(5, 3))
ax = fig.add_subplot(111)
ax.grid(False)
ax.set_xlim([minx - .5, maxx + .5])
ax.set_ylim([miny - .3, maxy + .5])
ax.set_aspect(1)
#uncomment for wireframe display
#for i in range(1,len(hallway_set)):
# hallway_set[i] = rotate(hallway_set[i], 90-a, origin=(0,0))
# x,y = hallway_set[i].exterior.xy
# plt.plot(x,y,linewidth=.4)
x, y = hallway_set[hway_num].exterior.xy
plt.plot(x, y, linewidth=.2, color='grey')
#plot one hallway
ax.add_patch(PolygonPatch(hallway, ec="none"))
plt.title(str(hallway.area) + "N:" + str(N))
fig.savefig("a:" + str(theta) + "_N:" + str(N) + "_Smth:" + str(smooth) +
"_j:" + str(hway_num) + ".png",
dpi=900)
plt.close()
def plotRedistrictingGroups(redistrictingGroups,
showPopulationCounts=False,
showGraphIds=False,
showDistrictNeighborConnections=False):
fig = pyplot.figure()
ax = fig.gca()
colorIndex = 0
for redistrictingGroup in redistrictingGroups:
if showDistrictNeighborConnections:
for neighborGroup in redistrictingGroup.allNeighbors:
if neighborGroup in redistrictingGroups:
ax.add_line(
getLineForPair(redistrictingGroup, neighborGroup,
grayColor))
ax.add_patch(
PolygonPatch(redistrictingGroup.geometry,
fc=getColor(colorIndex),
ec=getColor(colorIndex),
alpha=0.5,
zorder=2))
if showPopulationCounts:
centerOfGroup = redistrictingGroup.geometry.centroid
ax.text(x=centerOfGroup.x,
y=centerOfGroup.y,
s=redistrictingGroup.population,
fontdict=font)
if showGraphIds:
centerOfGroup = redistrictingGroup.geometry.centroid
ax.text(x=centerOfGroup.x,
y=centerOfGroup.y,
s=redistrictingGroup.graphId,
fontdict=font)
colorIndex += 1
ax.axis('scaled')
pyplot.show()
def catchment_plot_2sided(data,datacid,shpname,joinid_index,fn,maxcolorval):
#make a plot with 10 color gradations and a colorbar to go with it
base=plt.cm.get_cmap('seismic')
color_list=base(np.linspace(0,1,21))
seis21=base.from_list('seis21',color_list,21)
#cmap=jet
#ncar=plt.get_cmap('gist_ncar')
#define 10 colors in the list
#cmaplist=[jet(0),jet(25),jet(50),jet(75),jet(100),jet(125),jet(150),jet(175),jet(250),ncar(195)]
#cmap=cmap.from_list('Custom cmap',cmaplist,10)
fig=plt.figure()
ax=fig.add_axes([0,0,1,1])
#ax=fig.add_subplot(221)
data=np.squeeze(data)
#cmap=plt.cm.jet
polys=shp.Reader(shpname)
mymax=float(maxcolorval)
for r1,r2 in zip(polys.shapeRecords(),polys.records()):
shpcid=int(float(r2[joinid_index]))
val=data[datacid==shpcid]
poly=r1.shape.__geo_interface__
f=val/mymax
patch=PolygonPatch(poly,fc=seis21(f[0]),ec=seis21(f[0]),alpha=0.8)
ax.add_patch(patch)
ax.axis('scaled')
plt.savefig(fn,dpi=200)
plt.close()
#Plot colorbar
fig2=plt.figure()
ax2=fig2.add_axes([0.1,0.1,.8,0.2])
m=np.zeros((1,10))
for i in range(0,10):
m[0,i]=(i)/10.0
xtickvals=[k*mymax for k in [0,.1,.2,.3,.4,.5,.6,.7,.8,.9,1]]
ax2.imshow(m,cmap=jet10,interpolation='nearest',vmin=0,vmax=1,aspect=1)
ax2.set_yticks(np.arange(0))
ax2.set_xticks(np.linspace(-0.5,9.5,11))
ax2.set_xticklabels(xtickvals)
plt.savefig(fn+'_cbar.png',dpi=200)
plt.close()
def vis_polygon(ax,type,region,commune,color_type=''):
path = path_data+'{}/json/{}/'.format(type,region)
if not isinstance(commune,list):
communes = [commune]
filenames = []
for commune in communes:
filenames += glob.glob(path+'{}*'.format(commune))
for filename in filenames:
print(filename[-20:])
file = open(filename,'r')
json_data = json.load(file)
if color_type == 'greenspace':
greens = json_data['properties']['greenspace']
factor = 0.0
for green in greens:
if green[1] != 0:
factor += green[0]/(green[1]*green[1])
cmap = matplotlib.cm.get_cmap('viridis')
color = cmap(factor/1.0)
elif color_type == 'area':
cmap = matplotlib.cm.get_cmap('viridis')
area = json_data['properties']['area']
if area > 0.00001:
color = '#ff0000'
else:
color = '#00ff00'
else:
color = '#ffffff'
poly = json_data['geometry']
ax.add_patch(PolygonPatch(poly, fc=color, ec='#000000', lw=0.2, zorder=2))
ax.add_patch(Circle(json_data['properties']['center'], radius=0.00005, fc='#000000', ec='#000000', lw=0.2, zorder=2))
ax.axis('scaled')
ax.set_xlabel('lng')
ax.set_ylabel('lat')
def test_gml_repository():
if "RASPUTIN_DATA_DIR" not in os.environ:
raise RuntimeError("Please set RASPUTIN_DATA_DIR")
path = Path(os.environ["RASPUTIN_DATA_DIR"]) / "corine"
input_crs = pyproj.CRS.from_string("+init=EPSG:4326")
target_crs = pyproj.CRS.from_epsg(32633)
x = np.array([8.5, 8.52, 8.52, 8.5])
y = np.array([60.55, 60.55, 60.50, 60.50])
x, y = pyproj.Transformer.from_crs(input_crs, target_crs).transform(x, y)
domain = GeoPolygon(polygon=Polygon(shell=list(zip(x, y))), crs=target_crs)
repos = GMLRepository(path=path)
plot = False
if plot:
response = repos.read(domain=domain)
fig = plt.figure()
ax = fig.gca()
for key in response:
color = [c / 255 for c in LandCoverType.color(land_cover_type=key)]
for p in response[key]:
ax.add_patch(PolygonPatch(p, fc=color, alpha=0.5))
ax.set_xbound(min(x), max(x))
ax.set_ybound(min(y), max(y))
plt.show()
dem_archive = Path(os.environ["RASPUTIN_DATA_DIR"]) / "dem_archive"
rr = RasterRepository(directory=dem_archive)
raster_domain = domain.transform(
target_crs=pyproj.CRS.from_proj4(rr.coordinate_system(domain=domain)))
raster_data_list = rr.read(domain=raster_domain)
mesh = Mesh.from_raster(data=raster_data_list, domain=raster_domain)
cmesh = mesh.simplify(ratio=0.1)
geo_cell_centers = GeoPoints(xy=cmesh.cell_centers[:, :2], crs=target_crs)
terrain_cover = repos.land_cover(land_types=None,
geo_points=geo_cell_centers,
domain=domain)
assert terrain_cover is not None
def show_results_for_antenna_circle_cover(fileName) :
plt.figure(dpi=90)
# get the current axes.
ax = plt.gca()
f = open(fileName)
result = json.load(f)
coverage_filename = result["detection_coverage_file"]
indexes = result["indexes"]
angles = result["angles"]
center = result["center"]
points_to_cover = result["points_to_cover"]
detection_coverage = antennacover.read_detection_coverage(coverage_filename)
circ = None
for k in range(0,len(indexes)):
polygon = detection_coverage[indexes[k]][1]
rotated_cover = antennacover.rotate(polygon,angles[k])
rotated_translated_cover = antennacover.translate(rotated_cover,center)
if circ is None:
circ = rotated_translated_cover
else:
circ = circ.union(rotated_translated_cover)
p = PolygonPatch(rotated_translated_cover, fc=GRAY, ec=GRAY, alpha=0.5, zorder=2)
ax.add_patch(p)
for p in points_to_cover:
plot_point(ax,p,RED)
xmin = float(circ.bounds[0])
ymin = float(circ.bounds[1])
xmax = float(circ.bounds[2])
ymax = float(circ.bounds[3])
ax.set_xlim([xmin,xmax])
ax.set_ylim([ymin,ymax])
if os.path.dirname(fileName) != '':
mpl.rcParams["savefig.directory"] = os.chdir(os.path.dirname(fileName))
else:
mpl.rcParams["savefig.directory"] = os.chdir("./")
plt.show()
def plot_field(self):
lot_polygons = []
landuse = []
colours = []
for i in list(set(self.g.vs.select()['lot_number'])):
lots = self.g.vs.select(lot_number=i)
landuse = lots[0]['landuse']
colours.append(self.landuse_color_dic[landuse])
points = lots['coords']
polygons = []
for lot in points:
polygon = Polygon(lot)
polygons.append(polygon)
merge = cascaded_union(polygons)
merge_patch = PolygonPatch(merge)
lot_polygons.append(merge_patch)
pc = plt_c.PatchCollection(lot_polygons,
edgecolor='black',
facecolor=colours)
fig, ax = plt.subplots(figsize=(30, 50))
ax.set_aspect("equal")
ax.add_collection(pc)
ax.set_title('Fakefield City')
xrange = [-1, max(self.x_coords)]
yrange = [min(self.y_coords), -1]
ax.set_xlim(xrange)
ax.set_ylim(yrange)
ax.set_aspect(1)
def _plot_geometry(geom, fill='#ffcccc', stroke='#333333', alpha=1, msg=None):
from matplotlib import pyplot
from matplotlib.figure import SubplotParams
from descartes import PolygonPatch
if isinstance(geom, (Polygon, MultiPolygon)):
b = geom.bounds
geoms = hasattr(geom, 'geoms') and geom.geoms or [geom]
w, h = (b[2] - b[0], b[3] - b[1])
ratio = w / h
pad = 0.15
fig = pyplot.figure(1, figsize=(5, 5 / ratio), dpi=110, subplotpars=SubplotParams(left=pad, bottom=pad, top=1 - pad, right=1 - pad))
ax = fig.add_subplot(111, aspect='equal')
for geom in geoms:
patch1 = PolygonPatch(geom, linewidth=0.5, fc=fill, ec=stroke, alpha=alpha, zorder=0)
ax.add_patch(patch1)
p = (b[2] - b[0]) * 0.03 # some padding
pyplot.axis([b[0] - p, b[2] + p, b[3] + p, b[1] - p])
pyplot.grid(True)
if msg:
fig.suptitle(msg, y=0.04, fontsize=9)
pyplot.show()
def add_ring(ax=None, radius=None, mapping=False, color=None, lw=1):
from shapely.geometry import Polygon
from descartes import PolygonPatch
if mapping:
m = mapping[0]
olat = mapping[1]
olon = mapping[2]
c = Circlem.circle(m, olat, olon, radius * 1000.)
circraw = Polygon(c)
circ = PolygonPatch(circraw, fc='none', ec=color)
else:
circ = plt.Circle((0, 0),
radius,
fill=False,
color=color,
linewidth=lw)
ax.add_patch(circ)
return circ
def plot_bootstrapped_attributes_diagram(figure_object, axes_object,
ci_bottom_dict, ci_mean_dict,
ci_top_dict, num_examples_by_bin):
"""Bootstrapped version of plot_attributes_diagram.
:param figure_object: Instance of `matplotlib.figure.Figure`.
:param axes_object: Instance of `matplotlib.axes._subplots.AxesSubplot`.
:param ci_bottom_dict: See doc for `plot_bootstrapped_reliability_curve`.
:param ci_mean_dict: Same.
:param ci_top_dict: Same.
:param num_examples_by_bin: See doc for `plot_attributes_diagram`.
"""
plot_attributes_diagram(
figure_object=figure_object,
axes_object=axes_object,
mean_forecast_by_bin=ci_mean_dict[model_eval.MEAN_FORECAST_BY_BIN_KEY],
event_frequency_by_bin=ci_mean_dict[model_eval.EVENT_FREQ_BY_BIN_KEY],
num_examples_by_bin=num_examples_by_bin)
polygon_object = _confidence_interval_to_polygon(
x_coords_bottom=ci_bottom_dict[model_eval.MEAN_FORECAST_BY_BIN_KEY],
y_coords_bottom=ci_bottom_dict[model_eval.EVENT_FREQ_BY_BIN_KEY],
x_coords_top=ci_top_dict[model_eval.MEAN_FORECAST_BY_BIN_KEY],
y_coords_top=ci_top_dict[model_eval.EVENT_FREQ_BY_BIN_KEY])
if polygon_object is None:
return
polygon_colour = matplotlib.colors.to_rgba(
plotting_utils.colour_from_numpy_to_tuple(RELIABILITY_COLOUR),
POLYGON_OPACITY)
polygon_patch = PolygonPatch(polygon_object,
lw=0,
ec=polygon_colour,
fc=polygon_colour)
axes_object.add_patch(polygon_patch)
def getShapefile(excelFileName, excelSheetName, plotFlag):
# wb = load_workbook('MapLimitPoint.xlsx')
wb = load_workbook(excelFileName)
for i in range(len(excelSheetName)):
ws = wb[excelSheetName[i]]
print excelSheetName[i]
pointsArea = []
for row in ws.iter_rows(min_row=ws['A1'].value,
min_col=ws['B1'].value,
max_col=ws['C1'].value,
max_row=ws['D1'].value):
onePoint = []
for cell in row:
onePoint.append(cell.value)
pointsArea.append(onePoint)
# writing region boundary into a shape file
print 'shapefiles/CDShapeFiles/' + excelSheetName[i]
w = sf.Writer()
w.poly(parts=[pointsArea])
w.field('FIRST_FLD', 'C')
w.save('shapefiles/CDShapeFiles/' + excelSheetName[i])
# plot the shapefile
if plotFlag == 1:
fig = plt.figure()
BLUE = '#6699cc'
for i in range(len(excelSheetName)):
polys = sf.Reader("shapefiles/CDShapeFiles/" + excelSheetName[i] +
".shp")
poly = polys.iterShapes().next().__geo_interface__
ax = fig.gca()
ax.add_patch(
PolygonPatch(poly, fc=BLUE, ec=BLUE, alpha=0.5, zorder=2))
ax.axis('scaled')
plt.show()
return
def show_ship_polygons(img, polygons):
patches = []
for polygon in polygons:
patches.append(PolygonPatch(polygon))
patch_collection = PatchCollection(patches)
patch_collection.set_color('yellow')
fig, ax = plt.subplots(1, 1, figsize=(20, 20))
ax.imshow(img)
ax.set_xticks([])
ax.set_yticks([])
plt.savefig('./proc_img.png')
plt.show()
fig, ax = plt.subplots(1, 1, figsize=(20, 20))
ax.imshow(img)
ax.add_collection(patch_collection)
ax.autoscale()
ax.set_xticks([])
ax.set_yticks([])
plt.savefig('./masked_img.png')
plt.show()
def drawBBox(min_lon, min_lat, max_lon, max_lat, base_map, **kwargs):
"""
Draw bounding box on a basemap
:param min_lon: Minimum longitude
:type min_lon: float
:param min_lat: Minimum latitude
:type min_lat: float
:param max_lon: Maximum longitude
:type max_lon: float
:param max_lat: Maximum latitude
:type max_lat: float
:param base_map: Basemap on which to draw the bounding box
:type base_map: mpl_toolkits.basemap.Basemap
"""
bblons = np.array([min_lon, max_lon, max_lon, min_lon, min_lon])
bblats = np.array([min_lat, min_lat, max_lat, max_lat, min_lat])
x, y = base_map(bblons, bblats)
xy = zip(x, y)
poly = Polygon(xy)
base_map.ax.add_patch(PolygonPatch(poly, **kwargs))
def plot_gdf(gdf, margin=0.1):
"""
Plot GeoDataFrame and set the correst aspect ratio.
:param gdf: A :py:class:`Polygon` or :py:class:`MultiPolygon`
"""
ax = pyplot.gca()
ax.set_facecolor(COLOR_BACKGROUND)
polygon = gdf["geometry"].unary_union
patch = PolygonPatch(polygon, fc=COLOR_GROUND, ec=COLOR_GROUND, zorder=-1)
ax.add_patch(patch)
west, south, east, north = polygon.bounds
margin_ns = (north - south) * margin
margin_ew = (east - west) * margin
ax.set_xlim((west - margin_ew, east + margin_ew))
ax.set_ylim((south - margin_ns, north + margin_ns))
ax.set_aspect("equal")
def plot_environment(self):
minx, miny, maxx, maxy = self.env.bounds
max_width, max_height = 5, 5
figsize = (max_width, max_height)
f = plt.figure(figsize=figsize)
ax = f.add_subplot(111)
for i, obs in enumerate(self.env.obstacles):
patch = PolygonPatch(obs,
fc='blue',
ec='blue',
alpha=0.5,
zorder=20)
ax.add_patch(patch)
plt.xlim([minx, maxx])
plt.ylim([miny, maxy])
ax.set_aspect('equal', adjustable='box')
# Cancel coordinate axis display
ax.set_xticks([])
ax.set_yticks([])
return ax
def plotDebug(polygons, layerName, xrange, yrange):
"""
Plots the set of given polygons and gives the plot a title of layerName
:type polygons: list
:type layerName: str
:type xrange: tuple
:type yrange: tuple
"""
fig = pyplot.figure(1, figsize=(10, 10), dpi=90)
ax = fig.add_subplot(111)
for ob in polygons:
p = PolygonPatch(ob, fc='g', ec='g', alpha=0.5, zorder=1)
ax.add_patch(p)
ax.set_xlim(*xrange)
ax.set_ylim(*yrange)
ax.set_aspect(1)
ax.set_title(layerName)
pyplot.show()
def plot_polygon_data(
poly: Union[Polygon, MultiPolygon],
points: Union[MultiPoint, np.ndarray],
color_labels: np.ndarray,
bounds: Optional[Tuple] = None,
title: str = "",
) -> None:
points = maybe_to_array(points)
fig, ax = plt.subplots(dpi=120)
path = PolygonPatch(poly, fc=BLUE, ec=BLUE, alpha=0.4)
ax.add_patch(path)
gray = "#E6E6E3"
palette = sns.husl_palette(n_colors=max(color_labels)).as_hex()
if min(color_labels) == -1:
palette.append(gray)
color_labels[color_labels == -1] = max(color_labels) + 1
cmap = ListedColormap(palette)
ax.scatter(
x=points[:, 0],
y=points[:, 1],
alpha=0.8,
s=4 * 2,
c=color_labels,
cmap=cmap)
if title:
ax.set_title(title)
if bounds:
bounds = tuple(int(p) for p in bounds)
set_limits(ax, bounds[0], bounds[2], bounds[1], bounds[3])
else:
ax.autoscale_view()
plt.show()
def assign_neighborhood(lat, lon):
# Read in neighborhood shape file
hood_shapefilename = '/Users/sydneydecoto/Documents/PythonScripts/Neighborhoods/WGS84/Neighborhoods'
hood_coords = parse_shapes(hood_shapefilename)
w, h = hood_coords[2] - hood_coords[0], hood_coords[3] - hood_coords[1]
extra = 0.005
m = Basemap(projection='tmerc',
ellps='WGS84',
lon_0=np.mean([hood_coords[0], hood_coords[2]]),
lat_0=np.mean([hood_coords[1], hood_coords[3]]),
llcrnrlon=hood_coords[0] - extra * w,
llcrnrlat=hood_coords[1] - (extra * h),
urcrnrlon=hood_coords[2] + extra * w,
urcrnrlat=hood_coords[3] + (extra * h),
resolution='i',
suppress_ticks=True)
# get dataframe for plotting
_out, df_map = plot_prepper(m, hood_shapefilename, 'S_HOOD')
nbr_names = df_map['name'].unique()
# map neighborhoods to polygon patches
df_map['patches'] = df_map['poly'].map(
lambda x: PolygonPatch(x, ec='#111111', lw=.8, alpha=1., zorder=4))
# convert latitude and longitude to point on basemap
xpt, ypt = m(lon, lat)
pt = Point(xpt, ypt)
# loop through neighborhoods until neighborhood containing point is found
for polygon in df_map['poly']:
hood_name = df_map.loc[df_map['poly'] == polygon, 'name'].iloc[0]
if len(hood_name.strip()) < 4:
continue
if polygon.contains(pt):
return hood_name
def __init__(self, delta_state, start_angle = 0, isbackward=False):
length = 3.0
width = 2.0
self.delta_state = delta_state
self.start_angle = start_angle
self.cost = dubins.path_length((0,0,self.start_angle), delta_state, motion_primitive.turning_radius)
path_list, _ = dubins.path_sample((0,0,self.start_angle), self.delta_state,
motion_primitive.turning_radius, 0.1)
self.path = np.array(path_list)
self.isbackward = isbackward
if self.isbackward:
self.delta_state[:2] = -self.delta_state[:2] #(-0.25*np.cos(start_angle),-0.25*np.sin(start_angle),start_angle)
self.path[:,0:2] = -1*self.path[:,0:2]
#self.path = [(-xx,-yy,tth) for (xx,yy,tth) in self.path]
#self.cost *= 2
box_angle_tuples = [(box(x - length/2, y - width/2, x + length/2, y + width/2), theta) for (x,y,theta) in self.path]
polygons = [affinity.rotate(a_box, theta, origin = 'centroid', use_radians = True) for (a_box, theta) in box_angle_tuples]
if False:
fig = plt.figure(10)
fig.clear()
plt.ion()
ax = fig.add_subplot(111, aspect = 'equal')
for poly in polygons:
P = PolygonPatch(poly, fc = 'k', zorder = 2)
ax.add_patch(P)
ax.set_xlim(-5,5)
ax.set_ylim(-5,5)
fig.show()
polygons = [poly.buffer(0.1) for poly in polygons]
try:
self.bounding_poly = cascaded_union(polygons).simplify(0.05)
except:
raise Exception('No bounding poly for primitive')
def init_map(size_field, ax, radius):
size_field = 40
pos = []
polygons = []
for x in range(5, 40, 5):
for y in range(5, 40, 5):
pos.append((x, y))
for coord in pos:
dd = Point(coord[0], coord[1]).buffer(1)
rrwe = PolygonPatch(dd,
facecolor='#8A2BE2',
edgecolor='#8A2BE2',
alpha=0.9,
zorder=2)
ax.add_patch(rrwe)
polygons.append(dd)
ax.axis([0, size_field, 0, size_field], 'equal')
return polygons
def plot_polys(spatial_dict, axes, geojson=True):
'''
plot image with layer of spatial objects from dictionary
args:
spatial_dict: Keys are the class labels and values are polygons
axes: matplotlib axes object on which to plot
'''
if not bool(spatial_dict):
print("no polygons to plot")
else:
for class_label in spatial_dict.keys():
if geojson:
color_mapped = mapping_dict[class_label]
else:
color_mapped = class_label
for geom in spatial_dict[class_label]:
axes.add_patch(
PolygonPatch(geom,
alpha=0.65,
ec=colors[color_mapped],
fc=colors[color_mapped]))
def PlotDistrict(district, dims, filename):
minx, miny, maxx, maxy = dims
fig = plt.figure()
if isinstance(district['geom'], Polygon):
this_shape = MultiPolygon([district['geom']])
else:
this_shape = district['geom']
ax = fig.add_subplot(1, 1, 1)
w, h = maxx - minx, maxy - miny
ax.set_xlim(minx - 0.0 * w, maxx + 0.0 * w)
ax.set_ylim(miny - 0.0 * h, maxy + 0.0 * h)
ax.set_aspect(1)
ax.axis('off')
patches = [
PolygonPatch(p, fc="black", ec='#555555', alpha=1., zorder=1)
for p in this_shape
]
ax.add_collection(PatchCollection(patches, match_original=True))
print("Saving {0}".format(filename))
plt.savefig(filename, alpha=True, dpi=300, bbox_inches='tight')
plt.clf()
plt.cla()
plt.close()
def plot_solution_space(self):
# figure formatting
fig, ax = plt.subplots()
ax.axis('square')
ax.set_xlim(self.x_lim[0], self.x_lim[1])
ax.set_ylim(self.y_lim[0], self.y_lim[1])
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_title('Possible Hand Endpoint Locations')
# add the possible hand endpoints
ax.scatter(*zip(*self.possible_endpoints), 0.1)
# add a circle to show where the shoulder is
circle = patches.Circle((self.joints[0].location[0], self.joints[0].location[1]),
0.015, fill=True)
ax.add_patch(circle)
plt.annotate('shoulder',
(self.joints[0].location[0], self.joints[0].location[1]))
# add the alpha shape
ax.add_patch(PolygonPatch(self.alpha_shape, alpha=0.2))
