def test_patch(self):
geo = self.polygon.__geo_interface__
patch = PolygonPatch(geo)
self.failUnlessEqual(str(type(patch)),
"<class 'matplotlib.patches.PathPatch'>")
path = patch.get_path()
self.failUnless(len(path.vertices) == len(path.codes) == 198)
def plot(self, type_='pose', alpha=0.5, **kwargs):
"""Plot either the pose or point feasible regions.
Parameters
----------
type_ : {'pose','point'}
The type of feasible region to plot.
alpha : int
Feasible region patch transparency
**kwargs
Arguements passed to PolygonPatch
"""
if type_ == "pose":
p = self.pose_region
else:
p = self.point_region
ax.set_xlim([self.bounds[0], self.bounds[2]])
ax.set_ylim([self.bounds[1], self.bounds[3]])
self.patch = PolygonPatch(p, facecolor=cnames['black'],
alpha=alpha, zorder=2, **kwargs)
ax.add_patch(self.patch)
plt.show()
def plot(self):
levels_res = 50
self.levels = np.linspace(0, np.max(self.gm.pdf(self.pos)), levels_res)
self.contourf = self.ax.contourf(self.xx, self.yy,
self.gm.pdf(self.pos),
levels=self.levels,
cmap=plt.get_cmap('jet')
)
# Plot camera
self.cam_patch = PolygonPatch(self.detection_model.poly, facecolor='none',
linewidth=2, edgecolor='white')
self.ax.add_patch(self.cam_patch)
# Plot ellipses
self.ellipse_patches = self.gm.plot_ellipses(poly=self.detection_model.poly)
def draw_zone_map(ax, sf, shp_dic, heat={}, text=[], arrows=[]):
continent = [235 / 256, 151 / 256, 78 / 256]
ocean = (89 / 256, 171 / 256, 227 / 256)
theta = np.linspace(0, 2 * np.pi, len(text) + 1).tolist()
ax.set_facecolor(ocean)
# colorbar
if len(heat) != 0:
norm = mpl.colors.Normalize(vmin=0, vmax=max(
heat.values())) # norm = mpl.colors.LogNorm(vmin=1,vmax=max(heat))
cm = plt.get_cmap('Reds')
sm = plt.cm.ScalarMappable(cmap=cm, norm=norm)
sm.set_array([])
plt.colorbar(sm,
ticks=np.linspace(0, max(heat.values()), 8),
boundaries=np.arange(0 - 10,
max(heat.values()) + 10, 0.1))
for sr in sf.shapeRecords():
shape = sr.shape
rec = sr.record
loc_id = rec[shp_dic['LocationID']]
zone = rec[shp_dic['zone']]
if len(heat) == 0:
col = continent
else:
if loc_id not in heat:
R, G, B, A = cm(norm(0))
else:
R, G, B, A = cm(norm(heat[loc_id]))
col = [R, G, B]
# check number of parts (could use MultiPolygon class of shapely?)
nparts = len(shape.parts) # total parts
if nparts == 1:
polygon = Polygon(shape.points)
patch = PolygonPatch(polygon, facecolor=col, alpha=1.0, zorder=2)
ax.add_patch(patch)
else: # loop over parts of each shape, plot separately
for ip in range(nparts): # loop over parts, plot separately
i0 = shape.parts[ip]
if ip < nparts - 1:
i1 = shape.parts[ip + 1] - 1
else:
i1 = len(shape.points)
polygon = Polygon(shape.points[i0:i1 + 1])
patch = PolygonPatch(polygon,
facecolor=col,
alpha=1.0,
zorder=2)
ax.add_patch(patch)
x = (shape.bbox[0] + shape.bbox[2]) / 2
y = (shape.bbox[1] + shape.bbox[3]) / 2
if (len(text) == 0 and rec[shp_dic['Shape_Area']] > 0.0001):
plt.text(x,
y,
str(loc_id),
horizontalalignment='center',
verticalalignment='center')
elif len(text) != 0 and loc_id in text:
#plt.text(x+0.01, y-0.01, str(loc_id), fontsize=12, color="white", bbox=dict(facecolor='black', alpha=0.5))
eta_x = 0.05 * np.cos(theta[text.index(loc_id)])
eta_y = 0.05 * np.sin(theta[text.index(loc_id)])
ax.annotate("[{}] {}".format(loc_id, zone),
xy=(x, y),
xytext=(x + eta_x, y + eta_y),
bbox=dict(facecolor='black', alpha=0.5),
color="white",
fontsize=12,
arrowprops=dict(facecolor='black',
width=3,
shrink=0.05))
if len(arrows) != 0:
for arr in arrows:
ax.annotate('',
xy=arr['dest'],
xytext=arr['src'],
size=arr['cnt'],
arrowprops=dict(arrowstyle="fancy",
fc="0.6",
ec="none"))
# display
limits = get_boundaries(sf)
plt.xlim(limits[0], limits[1])
plt.ylim(limits[2], limits[3])
def plot_polygon_collection(ax,
geoms,
values=None,
color=None,
cmap=None,
vmin=None,
vmax=None,
**kwargs):
"""
Plots a collection of Polygon and MultiPolygon geometries to `ax`
Parameters
----------
ax : matplotlib.axes.Axes
where shapes will be plotted
geoms : a sequence of `N` Polygons and/or MultiPolygons (can be mixed)
values : a sequence of `N` values, optional
Values will be mapped to colors using vmin/vmax/cmap. They should
have 1:1 correspondence with the geometries (not their components).
Otherwise follows `color` / `facecolor` kwargs.
edgecolor : single color or sequence of `N` colors
Color for the edge of the polygons
facecolor : single color or sequence of `N` colors
Color to fill the polygons. Cannot be used together with `values`.
color : single color or sequence of `N` colors
Sets both `edgecolor` and `facecolor`
**kwargs
Additional keyword arguments passed to the collection
Returns
-------
collection : matplotlib.collections.Collection that was plotted
"""
try:
from descartes.patch import PolygonPatch
except ImportError:
raise ImportError("The descartes package is required"
" for plotting polygons in geopandas.")
from matplotlib.collections import PatchCollection
geoms, values = _flatten_multi_geoms(geoms, values)
if None in values:
values = None
# PatchCollection does not accept some kwargs.
if 'markersize' in kwargs:
del kwargs['markersize']
# color=None overwrites specified facecolor/edgecolor with default color
if color is not None:
kwargs['color'] = color
collection = PatchCollection([PolygonPatch(poly) for poly in geoms],
**kwargs)
if values is not None:
collection.set_array(np.asarray(values))
collection.set_cmap(cmap)
collection.set_clim(vmin, vmax)
ax.add_collection(collection, autolim=True)
ax.autoscale_view()
return collection
class camera_tester(object):
"""docstring for merged_gm"""
def __init__(self, prior, detection_model, trajectory, num_std=1, bounds=None):
self.fig = plt.figure(figsize=(16,8))
self.gm = prior
self.detection_model = detection_model
self.trajectory = itertools.cycle(trajectory)
self.vb = VariationalBayes()
self.num_std = num_std
if bounds is None:
self.bounds = [-5, -5, 5, 5]
else:
self.bounds = bounds
def update(self,i=0):
self.camera_pose = next(self.trajectory)
logging.info('Moving to pose {}.'.format(self.camera_pose))
self.detection_model.move(self.camera_pose)
# Do a VBIS update
mu, sigma, beta = self.vb.update(measurement='No Detection',
likelihood=detection_model,
prior=self.gm,
use_LWIS=True,
poly=detection_model.poly,
num_std=self.num_std
)
self.gm = GaussianMixture(weights=beta, means=mu, covariances=sigma)
# Log what's going on
logging.info(self.gm)
logging.info('Weight sum: {}'.format(beta.sum()))
self.remove()
self.plot()
def plot(self):
levels_res = 50
self.levels = np.linspace(0, np.max(self.gm.pdf(self.pos)), levels_res)
self.contourf = self.ax.contourf(self.xx, self.yy,
self.gm.pdf(self.pos),
levels=self.levels,
cmap=plt.get_cmap('jet')
)
# Plot camera
self.cam_patch = PolygonPatch(self.detection_model.poly, facecolor='none',
linewidth=2, edgecolor='white')
self.ax.add_patch(self.cam_patch)
# Plot ellipses
self.ellipse_patches = self.gm.plot_ellipses(poly=self.detection_model.poly)
def plot_setup(self):
# Define gridded space for graphing
min_x, max_x = self.bounds[0], self.bounds[2]
min_y, max_y = self.bounds[1], self.bounds[3]
res = 30
self.xx, self.yy = np.mgrid[min_x:max_x:1/res,
min_y:max_y:1/res]
pos = np.empty(self.xx.shape + (2,))
pos[:, :, 0] = self.xx; pos[:, :, 1] = self.yy;
self.pos = pos
# Plot setup
self.ax = self.fig.add_subplot(111)
self.ax.set_title('VBIS with camera detection test')
plt.axis('scaled')
self.ax.set_xlim([min_x, max_x])
self.ax.set_ylim([min_y, max_y])
levels_res = 50
self.levels = np.linspace(0, np.max(self.gm.pdf(self.pos)), levels_res)
cax = self.contourf = self.ax.contourf(self.xx, self.yy,
self.gm.pdf(self.pos),
levels=self.levels,
cmap=plt.get_cmap('jet')
)
self.fig.colorbar(cax)
def remove(self):
if hasattr(self, 'cam_patch'):
self.cam_patch.remove()
del self.cam_patch
if hasattr(self, 'ellipse_patches'):
for patch in self.ellipse_patches:
patch.remove()
del self.ellipse_patches
if hasattr(self,'contourf'):
for collection in self.contourf.collections:
collection.remove()
del self.contourf
with open('noise_info0.pickle', 'wb') as f:
pickle.dump(noise_info0, f, protocol=2)
fig1 = plt.figure(figsize=(15, 10), dpi=1000)
plt.title('Average Seismic Noise Second Peak Maximum PDS\n S Network | 2014')
plt.xlabel('Longitude (degrees)')
plt.ylabel('Latitude (degrees)')
cm = plt.cm.get_cmap('RdYlBu')
cmin, cmax = np.min(noise_info1[:, 2]), np.max(noise_info1[:, 2])
sc = plt.scatter(noise_info1[:, 0],
noise_info1[:, 1],
c=noise_info1[:, 2],
norm=LogNorm(vmin=100, vmax=3e4),
s=35,
cmap=cm)
col = plt.colorbar(sc)
col.ax.set_ylabel('Maximum Power Density Spectrum (V RMS)')
if shape_path is not None and UNIQUE_SHAPE is not None:
patch = PolygonPatch(UNIQUE_SHAPE, facecolor='white',\
edgecolor='k', zorder=1)
ax = fig.add_subplot(111)
ax.add_patch(patch)
fig1.savefig('station_pds_maxima/Peak2 PDS Average Maxima 2014.svg',
format='SVG')
with open('noise_info1.pickle', 'wb') as f:
pickle.dump(noise_info1, f, protocol=2)
def plot_2d_cluster_ellipsoids(clusters_loc,
clusters_cov,
data=None,
std_levels=[1, 2],
labels=None,
ax=None,
legend=False,
cl_names=None,
cl_colors=None):
n_levels = len(std_levels)
if isinstance(clusters_loc, list):
n_clusters = len(clusters_loc)
elif isinstance(clusters_loc, np.ndarray): # not supper robust here
n_clusters = clusters_loc.shape[0]
elif isinstance(clusters_loc, dict):
n_clusters = len(clusters_loc)
else:
print("Invalid input")
return
cluster_ellipsoids = np.zeros((n_clusters, n_levels), dtype=object)
for cl in range(n_clusters):
for jj, level in enumerate(std_levels):
cluster_ellipsoids[cl, jj] = \
get_2d_confidence_ellipse(mu=clusters_loc[cl], cov=clusters_cov[cl], n_std=level)
if cl_colors is None:
cl_colors = colors
elif isinstance(cl_colors, str):
cl_colors = [cl_colors]
n_colors = len(cl_colors)
if ax is None:
f, ax = plt.subplots()
label_patch = []
if data is not None:
ax.scatter(data[:, 0],
data[:, 1],
c=np.array(colors)[labels],
alpha=0.2)
facecolors = ['grey'] * n_clusters
else:
facecolors = cl_colors
if cl_names is None:
cl_names = ['cl' + str(cl) for cl in range(n_clusters)]
for cl in range(n_clusters):
for jj, level in enumerate(std_levels):
patch = PolygonPatch(cluster_ellipsoids[cl, jj],
facecolor=facecolors[np.mod(cl, n_colors)],
alpha=0.3)
ax.add_patch(patch)
label_patch.append(
mpatches.Patch(color=facecolors[np.mod(cl, n_colors)],
label=cl_names[cl],
alpha=0.7))
if legend:
ax.legend(handles=label_patch, frameon=False, loc=(1.05, 0))
_ = ax.axis('scaled')
return ax
def plot_background(ax, obj_polygon):
background_patch = PolygonPatch(obj_polygon,
facecolor=DARK_25, edgecolor=DARK_90, alpha=0.4, zorder=2)
ax.add_patch(background_patch)
if path is None:
exit()
outside = multiLevelPoly.bounds
outside = Polygon([(outside[0], outside[1]), (outside[0], outside[3]),
(outside[2], outside[3]), (outside[2], outside[1])])
#ploting
fig = pyplot.figure(1)
ax = fig.add_subplot(111)
for p in multiLevelPoly:
patch = PolygonPatch(p,
facecolor=methods.v_color(p),
edgecolor=methods.v_color(p),
alpha=0.5,
zorder=2)
ax.add_patch(patch)
ax.text(args["s"][0] + 7,
args["s"][1] + 15,
r'$\sigma_{\mathit{init}}$',
fontsize=13)
methods.plot_coords(ax, Point(args["s"]), c="#00FF00", z=6)
ax.text(args["t"][0] - 30,
args["t"][1] + 11,
r'$\Sigma_{\mathit{goal}}$',
fontsize=13)
methods.plot_coords(ax, Point(args["t"]), c="#FF0000", z=6)
def roll_out(self,
init_obj_pose,
show_final_only=True,
show_init=False,
discrtimestep=2e-1,
t_max=5):
self.obj.update_pose(init_obj_pose)
pose = init_obj_pose
pusher1 = copy.copy(self.pusher1)
pusher2 = copy.copy(self.pusher2)
if show_init:
patch = PolygonPatch(self.obj.poly_world, alpha=0.25, zorder=2)
self.ax.add_patch(patch)
# print ('--- start simulation ---')
start_time = time.time()
contacts_in_world = self.obj.eval_contact_with_2pushers(
pusher1, pusher2, pose)
if contacts_in_world[IN_CONTACT]:
contact_points = []
contact_normals = []
v_pushes = []
for i in range(len(contacts_in_world[POINTS])):
contact_points.append(
np.dot(np.linalg.inv(pose),
np.hstack((contacts_in_world[POINTS][i], 1.)))[:2])
contact_normals.append(
np.dot(np.linalg.inv(pose[:2, :2]),
contacts_in_world[NORMALS][i]))
v_pushes.append(
np.dot(np.linalg.inv(pose[:2, :2]),
contacts_in_world[V_PUSHES][i]))
contacts = contact_points, contact_normals, v_pushes, contacts_in_world[
IN_CONTACT]
if len(contacts[POINTS]) == 1: # single contact
v_obj, contact_mode = self.motion.compute_vel_single_contact(
contacts[V_PUSHES][0], contacts[POINTS][0],
contacts[NORMALS][0], self.contact_mu, self.obj.ls_coeff)
else: # multi contacts
v_obj = self.motion.compute_vel_multi_contacts(
contacts[V_PUSHES], contacts[POINTS], contacts[NORMALS],
self.contact_mu, self.obj.ls_A)
if np.linalg.norm(v_obj) < 1e-3:
print 'JAMMING or STOP MOVING'
else:
print 'NO CONTACT'
t_contact = contacts_in_world[TIME]
pusher1.update_pusher(pusher1.eval_pusher(t_contact))
pusher2.update_pusher(pusher2.eval_pusher(t_contact))
# IPython.embed()
t = 0
previous_pose = self.obj.pose
while t < t_max:
pose = self.obj.eval_pose(discrtimestep, v_obj)
new_poly = self.obj.compute_poly(pose)
pusher1.update_pusher(pusher1.eval_pusher(discrtimestep))
pusher2.update_pusher(pusher2.eval_pusher(discrtimestep))
if pusher1.poly.intersects(new_poly) or pusher2.poly.intersects(
new_poly):
if discrtimestep > 1e-5:
print discrtimestep
pusher1.update_pusher(pusher1.eval_pusher(-discrtimestep))
pusher2.update_pusher(pusher2.eval_pusher(-discrtimestep))
discrtimestep = discrtimestep / 10.
continue
else:
break
t += discrtimestep
contacts_in_world = self.obj.eval_contact_with_2pushers(
pusher1, pusher2, pose, tolerance=10. * discrtimestep)
if contacts_in_world[IN_CONTACT]:
self.obj.update_pose(pose)
if not show_final_only:
# self.plot_pusher(self.ax,pusher1.poly)
# self.plot_pusher(self.ax,pusher2.poly)
patch = PolygonPatch(self.obj.poly_world,
alpha=0.25,
zorder=2)
for pt in contacts_in_world[POINTS]:
self.ax.add_patch(patch)
self.ax.plot(pt[0], pt[1], 'o', color='#999999')
else:
if len(contacts_in_world[POINTS]) == 0:
print 'No contact'
break
contact_points = []
contact_normals = []
v_pushes = []
for i in range(len(contacts_in_world[POINTS])):
contact_points.append(
np.dot(np.linalg.inv(pose),
np.hstack((contacts_in_world[POINTS][i], 1.)))[:2])
contact_normals.append(
np.dot(np.linalg.inv(pose[:2, :2]),
contacts_in_world[NORMALS][i]))
v_pushes.append(
np.dot(np.linalg.inv(pose[:2, :2]),
contacts_in_world[V_PUSHES][i]))
contacts = contact_points, contact_normals, v_pushes, contacts_in_world[
IN_CONTACT]
if len(contacts[POINTS]) == 1: # single contact
v_obj, contact_mode = self.motion.compute_vel_single_contact(
contacts[V_PUSHES][0], contacts[POINTS][0],
contacts[NORMALS][0], self.contact_mu, self.obj.ls_coeff)
# print 'single contact'
else: # multi contacts
v_obj = self.motion.compute_vel_multi_contacts(
contacts[V_PUSHES], contacts[POINTS], contacts[NORMALS],
self.contact_mu, self.obj.ls_A)
# print 'multiple contacts'
# print contacts_in_world[POINTS]
# print v_obj
# raw_input()
if np.linalg.norm(previous_pose - pose) < 1e-4:
print 'STOP MOVING'
break
else:
previous_pose = pose
if np.linalg.norm(v_obj[:2]) + np.abs(v_obj[2]) < 1e-5:
print 'STOP MOVING'
print 'at t=', t, 's'
break
print("--- %s seconds ---" % (time.time() - start_time))
# print 'Final obj pose: ', self.obj.pose
patch = PolygonPatch(self.obj.poly_world,
color='b',
alpha=0.2,
zorder=2)
self.ax.add_patch(patch)
# self.plot_pusher(self.ax,pusher1.poly)
# self.plot_pusher(self.ax,pusher2.poly)
# IPython.embed()
return self.obj.pose
fig = pyplot.figure(1, figsize=SIZE, dpi=90)
# 1: valid polygon
ax = fig.add_subplot(121)
ext = [(0, 0), (0, 2), (2, 2), (2, 0), (0, 0)]
int = [(1, 0), (0.5, 0.5), (1, 1), (1.5, 0.5), (1, 0)][::-1]
polygon = Polygon(ext, [int])
plot_coords(ax, polygon.interiors[0])
plot_coords(ax, polygon.exterior)
patch = PolygonPatch(polygon,
facecolor=v_color(polygon),
edgecolor=v_color(polygon),
alpha=0.5,
zorder=2)
ax.add_patch(patch)
ax.set_title('a) valid')
xrange = [-1, 3]
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: invalid self-touching ring
class FeasibleLayer(Layer):
"""A representation of feasible map regions.
A polygon (or collection of polygons) that represent feasible
regions of the map. Feasible can be defined as either feasible robot
poses or unoccupied space.
.. image:: img/classes_Feasible_Layer.png
Parameters
----------
max_robot_radius : float, optional
The maximum radius of a circular approximation to the robot, used
to determine the feasible pose regions.
**kwargs
Arguments passed to the ``Layer`` superclass.
"""
def __init__(self, max_robot_radius=0.20, **kwargs):
super(FeasibleLayer, self).__init__(**kwargs)
self.max_robot_radius = max_robot_radius # [m] conservative estimate
self.point_region = None
self.pose_region = None
# self.define_feasible_regions()
def define_feasible_regions(self, static_elements):
"""Generate the feasible regions from a dictionary of static map elements.
Parameters
----------
static_elements : dict
A dictionary of map elements
"""
# TODO: feasible space should depend on map bounds, not layer bounds
feasible_space = box(*self.bounds)
self.point_region = feasible_space
self.pose_region = feasible_space.buffer(-self.max_robot_radius)
for element in static_elements:
# Ignore MapAreas
if isinstance(element, MapObject):
self.point_region = self.point_region.difference(element.shape)
buffered_shape = element.shape.buffer(self.max_robot_radius)
self.pose_region = self.pose_region.difference(buffered_shape)
def plot(self, type_='pose', alpha=0.5, **kwargs):
"""Plot either the pose or point feasible regions.
Parameters
----------
type_ : {'pose','point'}
The type of feasible region to plot.
alpha : int
Feasible region patch transparency
**kwargs
Arguements passed to PolygonPatch
"""
if type_ == "pose":
p = self.pose_region
else:
p = self.point_region
ax.set_xlim([self.bounds[0], self.bounds[2]])
ax.set_ylim([self.bounds[1], self.bounds[3]])
self.patch = PolygonPatch(p, facecolor=cnames['black'],
alpha=alpha, zorder=2, **kwargs)
ax.add_patch(self.patch)
plt.show()
# return patch
def remove(self):
"""Removes feasible region patch from plot"""
if hasattr(self, 'patch'):
self.patch.remove()
def update(self, type_='pose', i=0):
self.remove()
self.plot(type_)
def plot_polygon(ax, poly, color='red'):
a = np.asarray(poly.exterior)
# without Descartes, we could make a Patch of exterior
ax.add_patch(PolygonPatch(poly, facecolor=color, alpha=0.3))
ax.plot(a[:, 0], a[:, 1], color='black')
shape = shapeRec.shape
rec = shapeRec.record
# select polygon facecolor RGB vals based on record value
R = 1.
G = (rec[ndx1] - minrec) / (maxrec - minrec)
G = G * (G < 1.0) * (G > 0) + 1.0 * (G > 1.0)
B = 0.
# check number of parts (could use MultiPolygon class of shapely?)
nparts = len(shape.parts) # total parts
if nparts == 1:
polygon = Polygon(shape.points)
patch = PolygonPatch(polygon,
facecolor=[R, G, B],
edgecolor=[0, 0, 0],
alpha=1.0,
zorder=2)
ax.add_patch(patch)
else: # loop over parts of each shape, plot separately
for ip in range(nparts): # loop over parts, plot separately
i0 = shape.parts[ip]
if ip < nparts - 1:
i1 = shape.parts[ip + 1] - 1
else:
i1 = len(shape.points)
# build the polygon and add it to plot
polygon = Polygon(shape.points[i0:i1 + 1])
patch = PolygonPatch(polygon,
def plot_polygon_collection(
ax, geoms, values=None, color=None, cmap=None, vmin=None, vmax=None, **kwargs
):
"""
Plots a collection of Polygon and MultiPolygon geometries to `ax`
Parameters
----------
ax : matplotlib.axes.Axes
where shapes will be plotted
geoms : a sequence of `N` Polygons and/or MultiPolygons (can be mixed)
values : a sequence of `N` values, optional
Values will be mapped to colors using vmin/vmax/cmap. They should
have 1:1 correspondence with the geometries (not their components).
Otherwise follows `color` / `facecolor` kwargs.
edgecolor : single color or sequence of `N` colors
Color for the edge of the polygons
facecolor : single color or sequence of `N` colors
Color to fill the polygons. Cannot be used together with `values`.
color : single color or sequence of `N` colors
Sets both `edgecolor` and `facecolor`
**kwargs
Additional keyword arguments passed to the collection
Returns
-------
collection : matplotlib.collections.Collection that was plotted
"""
try:
from descartes.patch import PolygonPatch
except ImportError:
raise ImportError(
"The descartes package is required for plotting polygons in geopandas."
)
from matplotlib.collections import PatchCollection
from matplotlib.colors import is_color_like
geoms, multiindex = _flatten_multi_geoms(geoms, range(len(geoms)))
if values is not None:
values = np.take(values, multiindex, axis=0)
# PatchCollection does not accept some kwargs.
if "markersize" in kwargs:
del kwargs["markersize"]
if color is not None:
if is_color_like(color):
kwargs["color"] = color
elif pd.api.types.is_list_like(color):
kwargs["color"] = np.take(color, multiindex, axis=0)
else:
raise TypeError(
"Color attribute has to be a single color or sequence of colors."
)
else:
for att in ["facecolor", "edgecolor"]:
if att in kwargs:
if not is_color_like(kwargs[att]):
if pd.api.types.is_list_like(kwargs[att]):
kwargs[att] = np.take(kwargs[att], multiindex, axis=0)
elif kwargs[att] is not None:
raise TypeError(
"Color attribute has to be a single color or sequence "
"of colors."
)
collection = PatchCollection([PolygonPatch(poly) for poly in geoms], **kwargs)
if values is not None:
collection.set_array(np.asarray(values))
collection.set_cmap(cmap)
if "norm" not in kwargs:
collection.set_clim(vmin, vmax)
ax.add_collection(collection, autolim=True)
ax.autoscale_view()
return collection
def draw_region_map(ax, sf, shp_dic, heat={}):
continent = [235 / 256, 151 / 256, 78 / 256]
ocean = (89 / 256, 171 / 256, 227 / 256)
reg_list = {
'Staten Island': 1,
'Queens': 2,
'Bronx': 3,
'Manhattan': 4,
'EWR': 5,
'Brooklyn': 6
}
reg_x = {
'Staten Island': [],
'Queens': [],
'Bronx': [],
'Manhattan': [],
'EWR': [],
'Brooklyn': []
}
reg_y = {
'Staten Island': [],
'Queens': [],
'Bronx': [],
'Manhattan': [],
'EWR': [],
'Brooklyn': []
}
# colorbar
if len(heat) != 0:
norm = mpl.colors.Normalize(
vmin=math.sqrt(0), vmax=math.sqrt(max(heat.values(
)))) #norm = mpl.colors.LogNorm(vmin=1,vmax=max(heat))
cm = plt.get_cmap('Reds')
# sm = plt.cm.ScalarMappable(cmap=cm, norm=norm)
# sm.set_array([])
# plt.colorbar(sm, ticks=np.linspace(0,max(heat.values()),8), \
# boundaries=np.arange(0-10,max(heat.values())+10,.1))
ax.set_facecolor(ocean)
for sr in sf.shapeRecords():
shape = sr.shape
rec = sr.record
reg_name = rec[shp_dic['borough']]
if len(heat) == 0:
norm = mpl.colors.Normalize(
vmin=1,
vmax=6) #norm = mpl.colors.LogNorm(vmin=1,vmax=max(heat))
cm = plt.get_cmap('Pastel1')
R, G, B, A = cm(norm(reg_list[reg_name]))
col = [R, G, B]
else:
R, G, B, A = cm(norm(math.sqrt(heat[reg_name])))
col = [R, G, B]
# check number of parts (could use MultiPolygon class of shapely?)
nparts = len(shape.parts) # total parts
if nparts == 1:
polygon = Polygon(shape.points)
patch = PolygonPatch(polygon, facecolor=col, alpha=1.0, zorder=2)
ax.add_patch(patch)
else: # loop over parts of each shape, plot separately
for ip in range(nparts): # loop over parts, plot separately
i0 = shape.parts[ip]
if ip < nparts - 1:
i1 = shape.parts[ip + 1] - 1
else:
i1 = len(shape.points)
polygon = Polygon(shape.points[i0:i1 + 1])
patch = PolygonPatch(polygon,
facecolor=col,
alpha=1.0,
zorder=2)
ax.add_patch(patch)
reg_x[reg_name].append((shape.bbox[0] + shape.bbox[2]) / 2)
reg_y[reg_name].append((shape.bbox[1] + shape.bbox[3]) / 2)
for k in reg_list:
if len(heat) == 0:
plt.text(np.mean(reg_x[k]),
np.mean(reg_y[k]),
k,
horizontalalignment='center',
verticalalignment='center',
bbox=dict(facecolor='black', alpha=0.5),
color="white",
fontsize=12)
else:
plt.text(np.mean(reg_x[k]),
np.mean(reg_y[k]),
"{}\n({}K)".format(k, heat[k] / 1000),
horizontalalignment='center',
verticalalignment='center',
bbox=dict(facecolor='black', alpha=0.5),
color="white",
fontsize=12)
# display
limits = get_boundaries(sf)
plt.xlim(limits[0], limits[1])
plt.ylim(limits[2], limits[3])
from descartes.patch import PolygonPatch
from figures import DARKGRAY, GRAY, BLUE, SIZE, set_limits
fig = plt.figure(1, figsize=SIZE, dpi=90)
fig.set_frameon(True)
# 1
ax = fig.add_subplot(121)
mp = MultiPoint([(0, 0), (0.5, 1.5), (1, 0.5), (0.5, 0.5)])
rect = mp.minimum_rotated_rectangle
for p in mp:
ax.plot(p.x, p.y, 'o', color=GRAY)
patch = PolygonPatch(rect, facecolor=BLUE, edgecolor=BLUE, alpha=0.5, zorder=2)
ax.add_patch(patch)
ax.set_title('a) MultiPoint')
set_limits(ax, -1, 2, -1, 2)
# 2
ax = fig.add_subplot(122)
ls = LineString([(-0.5, 1.2), (0.5, 0), (1, 1), (1.5, 0), (1.5, 0.5)])
rect = ls.minimum_rotated_rectangle
ax.plot(*ls.xy, color=DARKGRAY, linewidth=3, alpha=0.5, zorder=2)
patch = PolygonPatch(rect, facecolor=BLUE, edgecolor=BLUE, alpha=0.5, zorder=2)
ax.add_patch(patch)
set_limits(ax, -1, 2, -1, 2)
def draw_channel(frame, layer, trackIDs, trackPolys, trackData, fileNameIMAGEOVERLAY,fsz):
numColors = 201
fig=plt.figure(1,frameon=True)
DPI = fig.get_dpi()
figxlim=fsz[0]
figylim=fsz[1]
figWidth=figxlim/float(DPI)
figHight=figylim/float(DPI)
fig.set_size_inches(figWidth,figHight)
ax = plt.axes()
ax.clear()
ax.axis("off")
ax.set_aspect('equal',adjustable='box')
plt.xlim(0,figxlim)
plt.ylim(0,figylim)
ax.plot([0, figxlim],[0,figylim],'w.') ##mmmmh
for i, this_trackID in enumerate(trackIDs):
this_poly=trackPolys[i]
this_data=trackData[i]
#Define overlay properties
if layer['channel']=='division': #CHANNEL: divisions
if this_data==1:
cellEdgeColor=[0,0,0]
cellColor=[1,1,0]
alphaCell=1.
else:
cellEdgeColor=[0.5,0.5,0.5]
cellColor=[0.9,0.9,0.9]
alphaCell=.5
elif layer['channel']=='GFP':
cmap= plt.cm.Greens(range(0, numColors))
if this_data==-1:
alphaCell=0
cellColor=[0.5,0.5,0.5]
cellEdgeColor=[0,0,0]
else:
xp=np.linspace(0,201,201)
fp=np.linspace(layer['minvalue'],layer['maxvalue'],201)
icolor=int(np.interp(this_data, fp, xp))
if icolor>numColors-1:
icolor=numColors-1
alphaCell=1
cellColor=cmap[icolor,:]
cellEdgeColor=[0,0,0]
elif layer['channel']=='DsRed':
cmap= plt.cm.Reds(range(0, numColors))
if this_data==-1:
alphaCell=0
cellColor=[0.5,0.5,0.5]
cellEdgeColor=[0,0,0]
else:
xp=np.linspace(0,201,201)
fp=np.linspace(layer['minvalue'],layer['maxvalue'],201)
icolor=int(np.interp(this_data, fp, xp))
if icolor>numColors-1:
icolor=numColors-1
alphaCell=1
cellColor=cmap[icolor,:]
cellEdgeColor=[0,0,0]
elif layer['channel']=='RYG':
#cmap= plt.cm.RdYlGn(range(0, numColors))
cmap = cm.get_cmap("RdYlGn", 201)
if this_data==-1:
alphaCell=0
cellColor=[0.9,0.9,0.9]
cellEdgeColor=[0.5,0.5,0.5]
else:
cellColor=cmap(1-this_data/np.pi)
alphaCell=1
cellEdgeColor=[0.5,0.5,0.5]
elif layer['channel']=='RelInt':
colors2=[(100,34,101),(92,204,192),(27,68,28)]
cmap=make_cmap(colors2, bit=True)
if this_data==-1:
alphaCell=0
cellColor=[0.9,0.9,0.9]
cellEdgeColor=[0.5,0.5,0.5]
else:
cellColor=cmap(1-this_data/np.pi)
alphaCell=1
cellEdgeColor=[0.5,0.5,0.5]
elif layer['channel']=='Tracking':
cellColor=this_data
cellEdgeColor=[0.5,0.5,0.5]
alphaCell=.5
else: #Mask
cellColor=[0,0,0]
cellEdgeColor=[0,0,0]
alphaCell=1
#Now draw polygon with overlay
if layer['contour']:
patch = PolygonPatch(this_poly, facecolor=cellColor, edgecolor=cellEdgeColor, alpha=alphaCell, linewidth=.5, zorder=2)
else:
patch = PolygonPatch(this_poly, facecolor=cellColor, edgecolor=cellColor, alpha=alphaCell, zorder=2)
ax.add_patch(patch)
plt.gca().invert_yaxis()
plt.tight_layout(pad=0,h_pad=0,w_pad=0)
fig.savefig(fileNameIMAGEOVERLAY)
#plt.close(fig1)
plt.clf()
plt.close(fig)
def plot_visible(ax, visible_regions):
for visibile_region in visible_regions:
visible_patch = PolygonPatch(visibile_region,
facecolor=DARK_50, edgecolor=DARK_90, alpha=0.6, zorder=2)
ax.add_patch(visible_patch)
def slice_non_fence_region(
regions,
xl,
yl,
xh,
yh,
macro_pos_x=None,
macro_pos_y=None,
macro_size_x=None,
macro_size_y=None,
merge=False,
plot=False,
figname="non_fence_region.png",
device=torch.device("cuda:0"),
):
if type(regions) == list:
if isinstance(regions[0], np.ndarray):
regions = torch.from_numpy(np.concatenate(regions, 0)).to(device)
elif isinstance(regions[0], torch.Tensor):
regions = torch.cat(regions, dim=0).to(device) # [n_box, 4]
elif isinstance(regions, np.ndarray):
regions = torch.from_numpy(regions).to(device)
if macro_pos_x is not None:
if isinstance(macro_pos_x, np.ndarray):
macro_pos_x = torch.from_numpy(macro_pos_x).to(device).float()
macro_pos_y = torch.from_numpy(macro_pos_y).to(device).float()
macro_size_x = torch.from_numpy(macro_size_x).to(device).float()
macro_size_y = torch.from_numpy(macro_size_y).to(device).float()
regions = torch.cat(
[
regions,
torch.stack([
macro_pos_x, macro_pos_y, macro_pos_x + macro_size_x,
macro_pos_y + macro_size_y
], 0).t(),
],
0,
)
num_boxes = regions.size(0)
regions = regions.view(num_boxes, 2, 2)
fence_regions = MultiPolygon([
box(regions[i, 0, 0], regions[i, 0, 1], regions[i, 1, 0],
regions[i, 1, 1]) for i in range(num_boxes)
])
fence_regions = unary_union(fence_regions)
site = box(xl, yl, xh, yh)
non_fence_region = unary_union(site.difference(fence_regions))
slices = []
xs = regions[:, :, 0].view(-1).sort()[0]
for i in range(xs.size(0) + 1):
x_l = xl if i == 0 else xs[i - 1]
x_h = xh if i == xs.size(0) else xs[i]
cvx_hull = box(x_l, yl, x_h, yh)
if x_l >= x_h or not cvx_hull.is_valid:
continue
intersect = non_fence_region.intersection(cvx_hull)
if isinstance(intersect, Polygon) and len(intersect.bounds) == 4:
slices.append(intersect.bounds)
elif isinstance(intersect, (GeometryCollection, MultiPolygon)):
slices.extend([
j.bounds for j in intersect
if (isinstance(j, Polygon) and len(j.bounds) == 4)
])
if merge:
raw_bbox_list = sorted(slices, key=lambda x: (x[1], x[0]))
cur_bbox = None
bbox_list = []
for i, p in enumerate(raw_bbox_list):
minx, miny, maxx, maxy = p
if cur_bbox is None:
cur_bbox = [minx, miny, maxx, maxy]
elif cur_bbox[1] == miny and cur_bbox[3] == maxy and cur_bbox[
2] == minx:
cur_bbox[2:] = p[2:]
else:
bbox_list.append(cur_bbox)
cur_bbox = [minx, miny, maxx, maxy]
else:
bbox_list.append(cur_bbox)
else:
bbox_list = slices
if plot:
from descartes.patch import PolygonPatch
from matplotlib import pyplot as plt
# from figures import BLUE, SIZE, set_limits, plot_coords, color_isvalid
res = []
bbox_list_np = np.array(bbox_list)
bbox_list_np *= 1000 / np.max(bbox_list_np)
for bbox in bbox_list_np:
res.append(box(*bbox.tolist()))
res = MultiPolygon(res)
fig = plt.figure(1, figsize=SIZE, dpi=90)
ax = fig.add_subplot(121)
for polygon in res:
# plot_coords(ax, polygon.exterior)
patch = PolygonPatch(
polygon,
facecolor=color_isvalid(non_fence_region),
edgecolor=color_isvalid(non_fence_region, valid=BLUE),
alpha=0.5,
zorder=2,
)
ax.add_patch(patch)
set_limits(ax, -1, 1000, -1, 1000, dx=100, dy=100)
# ax = fig.add_subplot(122)
# patch = PolygonPatch(non_fence_region, facecolor=color_isvalid(
# non_fence_region), edgecolor=color_isvalid(non_fence_region, valid=BLUE), alpha=0.5, zorder=2)
# ax.add_patch(patch)
# set_limits(ax, -1, 1000, -1, 1000, dx=100, dy=100)
plt.savefig(figname)
plt.close()
bbox_list = torch.tensor(bbox_list, device=device)
# print("non fence region area after slicing:", ((bbox_list[:,2]-bbox_list[:,0])*(bbox_list[:,3]-bbox_list[:,1])).sum().item())
return bbox_list
def create_patch_overlap_coord():
'''This part of the code creates the path image with overlapping coordinates'''
# img = openslide.OpenSlide(arg.svs_file)
# img_dim = img.level_dimensions[0]
# patch_size=10000
# """
# Determine what the patch size should be, and how many iterations it will take to get through the WSI
# """
# #num_x_patches = int(math.floor(img_dim[0]/patch_size))
# #num_y_patches = int(math.floor(img_dim[1]/patch_size))
# #print(str(num_x_patches)+" "+str(num_y_patches))
# print(len(regions))
# coords1=regions[8]
# min=np.argmin(coords1, axis = 0)
# #print(coords1[min[0]][0])
# #print(coords1[min[1]][1])
# #coords2=np.sort(coords1, axis = 0)
# #print(coords2)
# #sys.exit(1)
# x1=int(coords1[min[0]][0])-10
# y1=int(coords1[min[1]][1])-10
# level=0
# img_data = img.read_region((x1,y1),level, (patch_size, patch_size))
# img_data_np = np.array(img_data)
# img_name="sample.png"
# im = Image.fromarray(img_data_np)
# im.save(img_name)
# # Create figure and axes
# #fig,ax = plt.subplots(1)
# fig,ax = plt.subplots()
# # Display the image
# ax.imshow(img_data_np)
# #imgdata = plt.imread("sample.png")
# #ax.imshow(imgdata)
# # Add the patch to the Axes
# #points = [[2, 1], [8, 1], [8, 4],[50,50],[100,100],[200,200]]
# #plt.Polygon(points)
# #poly = Polygon(verts, facecolor='0.9', edgecolor='0.5')
# coords1_list=[]
# for i in range(0,len(coords1)):
# x_cor=int(coords1[i][0])-x1
# y_cor=int(coords1[i][1])-y1
# if x_cor >=0 and x_cor <= patch_size and y_cor >=0 and y_cor <=patch_size:
# tmp=(x_cor,y_cor)
# coords1_list.append(tmp)
# #coords1_list.append((100,300))
# #coords1_list.append((200,200))
# #coords1_list.append((400,200))
# #coords1_list.append((500,300))
# #coords1_list.append((400,400))
# #coords1_list.append((200,400))
# print(coords1_list)
# polygon = Polygon(coords1_list)
# patch = PolygonPatch(polygon, facecolor=[0,0,0], edgecolor=[0,0.5,0], alpha=0.7, zorder=2)
# ax.add_patch(patch)
# plt.savefig('sample_overlay.png', alpha=True, dpi=300)
# plt.show()
patch_size = 2000
OSobj = openslide.OpenSlide(arg.svs_file)
x1 = 40000
y1 = 37000
img_patch = OSobj.read_region((x1, y1), 0, (patch_size, patch_size))
img_data_np = np.array(img_patch)
#img_name="sample3.png"
#im = Image.fromarray(img_data_np)
#im.save(img_name)
# coords1_list=[]
# # #for j in range(0,len(regions)):
# for j in range(0,1):
# coords1=regions[j]
# for i in range(0,len(coords1)):
# x_cor=int(coords1[i][0])-x1
# y_cor=int(coords1[i][1])-y1
# # # #print(str(x_cor)+" "+str(y_cor))
# if x_cor >=0 and x_cor <= patch_size and y_cor >=0 and y_cor <=patch_size:
# tmp=(x_cor,y_cor)
# coords1_list.append(tmp)
# # # print(coords1_list)
# polygon = Polygon(coords1_list)
# # print(polygon)
# # # # Create figure and axes
# fig,ax = plt.subplots()
# # # # Display the image
# ax.imshow(img_data_np)
# # # # Add the patch to the Axes
# patch = PolygonPatch(polygon, facecolor=[0,0,0], edgecolor=[0,0.5,0], alpha=0.7, zorder=2)
# ax.add_patch(patch)
# plt.savefig('sample_overlay.png', alpha=True, dpi=300)
# plt.show()
# #ploting Steve's way
# #plt.style.use('dark_background')
# f, ax = plt.subplots(frameon=False)
# #f.set_facecolor('#eafff5')
# #ax.set_facecolor('#eafff5')
# f.tight_layout(pad=0, h_pad=0, w_pad=0)
# ax.set_xlim(0, patch_size)
# ax.set_ylim(0, patch_size)
# #img_data_np[np.where((img_data_np != [0,0,0]).all(axis = 2))] = [0,0,0]
# #ax.imshow(img_data_np)
# #mask1 = np.zeros(img_data_np.shape, dtype = "uint8")
# #mask1.fill(0)
# mask1 = Image.new('RGBA', (patch_size, patch_size), "black")
# ax.imshow(mask1)
# #ax.set_axis_bgcolor("black")
# #patch = PolygonPatch(polygon, facecolor=[0,0,0], edgecolor=[0,0.5,0], alpha=0.7, zorder=2)
# #patch = PolygonPatch(polygon, facecolor='#FFFFFF', edgecolor='#FFFFFF', alpha=0.7, zorder=2)
# patch = PolygonPatch(polygon, facecolor='white')
# ax.add_patch(patch)
# ax.set_axis_off()
# DPI = f.get_dpi()
# plt.subplots_adjust(left=0, bottom=0, right=1, top=1,wspace=0, hspace=0)
# f.set_size_inches(patch_size / DPI, patch_size / DPI)
# f.savefig("Mask_tmp.png", pad_inches='tight')
#create a binary mask
#mask = np.zeros(img_data_np, dtype = "uint8")
#cv2.rectangle(mask, (x1, y1), (x1+patch_size, y1+patch_size), (255, 255, 255), -1)
#print(img_data_np)
# flag = np.array([37500,38000, 0,0])
# #flag = np.array([36000,27000])
# #img_data_np=img_data_np+flag
# #mask = np.zeros((700,700))
# #print(regions[0])
# a=finalcoords
# a=np.int64(a)-flag
# a = a[~np.all(a < 0, axis=1)]
# a = a[~np.all(a > 10000, axis=1)]
# #print("sucess")
# #a2=a1[np.logical_and(a1>=0,a1<700)]
# print(a)
# sys.exit(1)
# poly = Polygon(regions[0])
# #img = Image.new('L', (700,700), 0)
# #ImageDraw.Draw(img).polygon(poly, outline=1, fill=1)
# mask = np.array((700,700))
# # Create vertex coordinates for each grid cell...
# # (<0,0> is at the top left of the grid in this system)
# #x, y = np.meshgrid(np.arange(700), np.arange(700))
# #x, y = x.flatten(), y.flatten()
# #points = np.vstack((x,y)).T
# #grid = points_inside_poly(points, poly)
# #grid = grid.reshape((ny,nx))
# print(poly)
# cv2.fillPoly(mask, poly, 1)
# mask = mask.astype(bool)
# plt.imshow(mask)
#print(Polygon(img_data_np).contains(poly_regions[0]))
#xmax, ymax = a.max(axis=0)
#print(img_data_np.shape)
#a = Polygon(np.array([(0, 0), (1, 1), (1,2), (2,2)]))
#b = Polygon(np.array([(0, 0), (1, 1), (2,1), (2,2)]))
# patch_list=[]
# x_n=300
# y_n=300
# size=x_n+y_n+x_n-2+y_n-2
# list1=[]
# n=0
# for x in range(0,x_n):
# tlist=[0+39000,x+34000]
# list1.append(tlist)
# for x in range(0,x_n):
# tlist=[x_n-1+39000,x+34000]
# list1.append(tlist)
# for x in range(1,y_n-1):
# tlist=[x+39000,0+34000]
# list1.append(tlist)
# for x in range(1,y_n-1):
# tlist=[x+39000,y_n-1+34000]
# list1.append(tlist)
path_poly = geo.box(x1, y1, x1 + patch_size, y1 + patch_size, ccw=True)
# # path_poly=Polygon(np.array(list1))
# # #path_poly=Polygon(np.array([[0, 0], [1, 0], [1, 1], [0, 1]]))
# # print(path_poly)
# # print(path_poly.is_valid)
# # print(path_poly.length)
# #print(poly_regions[0].is_valid)
#print(len(poly_regions))
poly_all = []
for j in range(0, len(poly_regions)):
#print(j)
poly1 = path_poly.intersection(poly_regions[j])
poly1_temp = []
if poly1.length > 0:
for x, y in poly1.exterior.coords:
x = int(x) - x1
y = int(y) - y1
tmp = (x, y)
poly1_temp.append(tmp)
poly1 = Polygon(poly1_temp)
poly_all.append(poly1)
#multi_poly = MultiPolygon(poly_all)
#print(len(poly_all))
#sys.exit(1)
#ploting Steve's way
#plt.style.use('dark_background')
f, ax = plt.subplots(frameon=False)
#ax.set_facecolor('#eafff5')
f.tight_layout(pad=0, h_pad=0, w_pad=0)
ax.set_xlim(0, patch_size)
ax.set_ylim(0, patch_size)
mask1 = Image.new('RGBA', (patch_size, patch_size), "black")
ax.imshow(mask1)
#patch1 = PolygonPatch(poly1, facecolor="white", edgecolor="white", alpha=0.7, zorder=2)
for j in range(0, len(poly_all)):
patch1 = PolygonPatch(poly_all[j], facecolor="white")
ax.add_patch(patch1)
ax.set_axis_off()
DPI = f.get_dpi()
plt.subplots_adjust(left=0, bottom=0, right=1, top=1, wspace=0, hspace=0)
f.set_size_inches(patch_size / DPI, patch_size / DPI)
f.savefig("Mask_tmp1.png", pad_inches='tight')
def gen_macros_for_fence_region(macro_pos_x,
macro_pos_y,
macro_size_x,
macro_size_y,
regions,
xl,
xh,
yl,
yh,
merge=False,
plot=False):
# tt = time.time()
macros = MultiPolygon([
box(
macro_pos_x[i],
macro_pos_y[i],
macro_pos_x[i] + macro_size_x[i],
macro_pos_y[i] + macro_size_y[i],
) for i in range(macro_size_x.size(0))
])
# print("macro:", time.time()-tt)
# tt = time.time()
num_boxes = regions.size(0)
regions = regions.view(num_boxes, 2, 2)
fence_regions = MultiPolygon([
box(regions[i, 0, 0], regions[i, 0, 1], regions[i, 1, 0],
regions[i, 1, 1]) for i in range(num_boxes)
])
site = box(xl, yl, xh, yh)
reverse = site.difference(fence_regions).union(macros)
# print("fence region:", time.time()-tt)
# tt = time.time()
slices = []
xs = torch.cat(
[regions[:, :, 0].view(-1), macro_pos_x, macro_pos_x + macro_size_x],
dim=0).sort()[0]
for i in range(xs.size(0) + 1):
x_l = xl if i == 0 else xs[i - 1]
x_h = xh if i == xs.size(0) else xs[i]
cvx_hull = box(x_l, yl, x_h, yh)
intersect = reverse.intersection(cvx_hull)
if isinstance(intersect, Polygon):
slices.append(intersect.bounds)
elif isinstance(intersect, (GeometryCollection, MultiPolygon)):
slices.extend(
[j.bounds for j in intersect if (isinstance(j, Polygon))])
# print("slicing:", time.time()-tt)
# tt = time.time()
if merge:
raw_bbox_list = sorted(slices, key=lambda x: (x[1], x[0]))
cur_bbox = None
bbox_list = []
for i, p in enumerate(raw_bbox_list):
minx, miny, maxx, maxy = p
if cur_bbox is None:
cur_bbox = [minx, miny, maxx, maxy]
elif cur_bbox[1] == miny and cur_bbox[3] == maxy:
cur_bbox[2:] = p[2:]
else:
bbox_list.append(cur_bbox)
cur_bbox = [minx, miny, maxx, maxy]
else:
bbox_list.append(cur_bbox)
else:
bbox_list = slices
# print("merge:", time.time()-tt)
bbox_list = torch.tensor(bbox_list).float()
pos_x = bbox_list[:, 0]
pos_y = bbox_list[:, 1]
node_size_x = bbox_list[:, 2] - bbox_list[:, 0]
node_size_y = bbox_list[:, 3] - bbox_list[:, 1]
if plot:
from descartes.patch import PolygonPatch
from matplotlib import pyplot as plt
from figures import BLUE, SIZE, color_isvalid, plot_coords, set_limits
res = []
for bbox in bbox_list:
res.append(box(*bbox))
res = MultiPolygon(res)
fig = plt.figure(1, figsize=SIZE, dpi=90)
ax = fig.add_subplot(121)
for polygon in res:
# plot_coords(ax, polygon.exterior)
patch = PolygonPatch(
polygon,
facecolor=color_isvalid(fence_regions),
edgecolor=color_isvalid(fence_regions, valid=BLUE),
alpha=0.5,
zorder=2,
)
ax.add_patch(patch)
set_limits(ax, -1, 20, -1, 20)
ax = fig.add_subplot(122)
patch = PolygonPatch(
reverse,
facecolor=color_isvalid(reverse),
edgecolor=color_isvalid(reverse, valid=BLUE),
alpha=0.5,
zorder=2,
)
ax.add_patch(patch)
set_limits(ax, -1, 20, -1, 20)
plt.savefig("polygon.png")
return pos_x, pos_y, node_size_x, node_size_y
def make_map(final_regions, file_name, number, x, y, country, algorithm,
order_choice):
# Open shapefile for country and plot figure
sf = shp.Reader(file_name)
plt.figure()
ax = plt.axes()
# Add plot title with country name
plt.title(country + ", algorithm " + algorithm + ", " + order_choice,
fontsize=20)
# Initialize counter for number of region
counter = 0
name_list = []
for i in list(sf.iterRecords()):
# Append region names to name list
name_list.append(list(sf.iterRecords())[counter][number])
counter += 1
counter = 0
for shape in list(sf.iterShapes()):
# Get color for region
color_value = name_list[counter]
color = colours(final_regions)
# Get dict with region and color for map
color_regions = color[0]
# Get dict with station and color for legend
color_legend = color[1]
# Check how many parts one region has
nparts = len(shape.parts)
# If region is made up of one part color whole part
if nparts == 1:
polygon = Polygon(shape.points)
patch = PolygonPatch(polygon, facecolor=color_regions[color_value])
ax.add_patch(patch)
# If more than one part then color every part of region the same color
else:
for ip in range(nparts):
iO = shape.parts[ip]
if ip < nparts - 1:
il = shape.parts[ip + 1] - 1
else:
il = len(shape.points)
polygon = Polygon(shape.points[iO:il + 1])
patch = PolygonPatch(polygon,
facecolor=color_regions[color_value])
ax.add_patch(patch)
counter += 1
# Add legend to plot
station_1 = mlines.Line2D([], [],
color=color_legend["1"],
marker="s",
fillstyle="full",
label='Station 1',
markersize=15)
station_2 = mlines.Line2D([], [],
color=color_legend["2"],
marker="s",
fillstyle="full",
label='Station 2',
markersize=15)
station_3 = mlines.Line2D([], [],
color=color_legend["3"],
marker="s",
fillstyle="full",
label='Station 3',
markersize=15)
station_4 = mlines.Line2D([], [],
color=color_legend["4"],
marker="s",
fillstyle="full",
label='Station 4',
markersize=15)
station_5 = mlines.Line2D([], [],
color=color_legend["5"],
marker="s",
fillstyle="full",
label='Station 5',
markersize=15)
station_6 = mlines.Line2D([], [],
color=color_legend["6"],
marker="s",
fillstyle="full",
label='Station 6',
markersize=15)
station_7 = mlines.Line2D([], [],
color=color_legend["7"],
marker="s",
fillstyle="full",
label='Station 7',
markersize=15)
plt.legend(handles=[
station_1, station_2, station_3, station_4, station_5, station_6,
station_7
],
shadow=True,
fancybox=True,
prop={'size': 12})
# Scale to country coordinates
plt.xlim(x)
plt.ylim(y)
plt.show()
def plotPoly(self, p, c):
patch = PolygonPatch(p, facecolor=c)
self.ax.add_patch(patch)
return patch
def plot_hex_to_square_map(coef, hex_cells_dict, sq_cells_dict):
'''
DESCRIPTION:
This function is for visualization of mapping of Hexagonal cells
to the square cells, for checking the correctness of resolution
of interpolation with the criteria as mentioned by Florian Sir,
(one square cell not overlapping with more than three hexagon cells)
USAGE:
This function is called internally in main.py generate_interpolation
function.
INPUT:
coef : the coef dictionary mapping each hexagonal cells to their
correspoinding square cells
hex_cells_dict : the dictionary of hexagonal cells obtained from
the root file
sq_cells_dict : the square cell dictionary generated by
get_square_cells function above and saved in
'sq_cells_data' directory in current location
OUTPUT:
Currently no output from this function
'''
t0 = datetime.datetime.now()
print '>>> Calculating the area of smallar cell for filtering'
filter_hex_cells = ([
c.vertices.area for c in hex_cells_dict.values()
if len(list(c.vertices.exterior.coords)) == 7
])
small_wafer_area = min(filter_hex_cells)
t1 = datetime.datetime.now()
print '>>> Area calculated %s in time: %s sec' % (small_wafer_area,
t1 - t0)
t0 = t1
for hex_id, sq_overlaps in coef.items():
hex_cell = hex_cells_dict[hex_id]
poly = hex_cell.vertices
#Filtering the cells in smaller region
if poly.area != small_wafer_area:
continue
fig = plt.figure()
ax1 = fig.add_subplot(111)
x, y = poly.exterior.xy
ax1.plot(x, y, 'o', zorder=1)
patch = PolygonPatch(poly, alpha=0.5, zorder=2, edgecolor='blue')
ax1.add_patch(patch)
print '>>> Plotting hex cell: ', hex_id
for sq_cell_data in sq_overlaps:
sq_cell_id = sq_cell_data[0]
overlap_coef = sq_cell_data[1]
sq_cell = sq_cells_dict[sq_cell_id]
print('overlapping with sq_cell: ', sq_cell_id,
'with overlap coef: ', overlap_coef)
poly = sq_cell.polygon
x, y = poly.exterior.xy
ax1.plot(x, y, 'o', zorder=1)
patch = PolygonPatch(poly, alpha=0.5, zorder=2, edgecolor='red')
ax1.add_patch(patch)
t1 = datetime.datetime.now()
print 'one hex cell overlap complete in: ', t1 - t0, ' sec\n'
plt.show()
for imageId in trainImageIds:
fig, axArr, ax = visualize_image(imageId, plot_all=False)
plt.savefig('Objects--' + imageId + '.png')
plt.clf()
def makeClassMap(imageId, nClass):
poly = wkt_loads(df[df.ImageId == imageId].MultipolygonWKT.values[nClass])
(xmax, ymin, W, H) = get_size(imageId)
# Optionally, view images immediately:
# pylab.show()
# Uncomment to show plot when interactive mode is off
# (this function blocks till fig is closed)
# My code
testId = '6100_1_3'
df[df.ImageId == testId]
gs[gs.ImageId == testId]
pp = wkt_loads(df[df.ImageId == testId].MultipolygonWKT.values[1])
fig, axArr = plt.subplots(figsize=(20, 20))
for polygon in pp:
mpl_poly = PolygonPatch(polygon, color='0.7', lw=0, alpha=0.7, zorder=1)
axArr.add_patch(mpl_poly)
axArr.autoscale_view()
axArr.set_title('Objects')
axArr.set_xticks([])
axArr.set_yticks([])
def _plot_polygon_collection(
ax, geoms, values=None, color=None, cmap=None, vmin=None, vmax=None, **kwargs
):
"""
Plots a collection of Polygon and MultiPolygon geometries to `ax`
Parameters
----------
ax : matplotlib.axes.Axes
where shapes will be plotted
geoms : a sequence of `N` Polygons and/or MultiPolygons (can be mixed)
values : a sequence of `N` values, optional
Values will be mapped to colors using vmin/vmax/cmap. They should
have 1:1 correspondence with the geometries (not their components).
Otherwise follows `color` / `facecolor` kwargs.
edgecolor : single color or sequence of `N` colors
Color for the edge of the polygons
facecolor : single color or sequence of `N` colors
Color to fill the polygons. Cannot be used together with `values`.
color : single color or sequence of `N` colors
Sets both `edgecolor` and `facecolor`
**kwargs
Additional keyword arguments passed to the collection
Returns
-------
collection : matplotlib.collections.Collection that was plotted
"""
try:
from descartes.patch import PolygonPatch
except ImportError:
raise ImportError(
"The descartes package is required for plotting polygons in geopandas. "
"You can install it using 'conda install -c conda-forge descartes' or "
"'pip install descartes'."
)
from matplotlib.collections import PatchCollection
geoms, multiindex = _flatten_multi_geoms(geoms)
if values is not None:
values = np.take(values, multiindex, axis=0)
# PatchCollection does not accept some kwargs.
kwargs = {
att: value
for att, value in kwargs.items()
if att not in ["markersize", "marker"]
}
# Add to kwargs for easier checking below.
if color is not None:
kwargs["color"] = color
_expand_kwargs(kwargs, multiindex)
collection = PatchCollection([PolygonPatch(poly) for poly in geoms], **kwargs)
if values is not None:
collection.set_array(np.asarray(values))
collection.set_cmap(cmap)
if "norm" not in kwargs:
collection.set_clim(vmin, vmax)
ax.add_collection(collection, autolim=True)
ax.autoscale_view()
return collection
def test_patch(self):
patch = PolygonPatch(self.thing)
self.failUnlessEqual(str(type(patch)),
"<class 'matplotlib.patches.PathPatch'>")
path = patch.get_path()
self.failUnless(len(path.vertices) == len(path.codes) == 198)
# print("Threshold value:", crimeThreshold)
# for value in blockCrimeRate_dict.values():
# if value[1] > crimeThreshold:
# polygon = polygons[value[0]]
# patch = PolygonPatch(polygon, facecolor='yellow', edgecolor='yellow', alpha=1)
# ax.add_patch(patch)
# userMap.blockedPolygons.append(polygon)
# else:
# break;
crimeData = list(blockCrimeRate_dict.values())
# print(len(crimeData))
for i in range(len(crimeData)):
if i < thresholdIndex:
polygon = userMap.polygons[crimeData[i][0]]
patch = PolygonPatch(polygon, facecolor='yellow', edgecolor='yellow', alpha=1)
ax.add_patch(patch)
userMap.blockedPolygons.append(polygon)
else:
break;
for i in range(len(userMap.polygons)):
x1, y1 = userMap.polygons[i].bounds[0], userMap.polygons[i].bounds[1]
node = Node(x1, y1, 0)
childNodes = []
cellsize = userMap.cellsize
if(is_inside_area(x1, y1+cellsize, userMap)) :
edgeCost = get_edge_cost(x1, y1, x1, y1+cellsize, userMap.blockedPolygons, False, "T")
if(edgeCost > 0):
childNodes.append(Node(x1, y1+cellsize, edgeCost))
def affine_h(geom, m):
return affine_transform(
geom, [m[0, 0], m[0, 1], m[1, 0], m[1, 1], m[0, 2], m[1, 2]])
ax = plt.axes()
p1 = Polygon([(0, 0), (0, 2), (2, 2), (2, 0), (0, 0)])
p2 = affine_h(p1, transl(0, 1) @ rot(pi / 4, 0, 0))
patch = PolygonPatch(p1,
facecolor='#ff3333',
edgecolor='#6699cc',
alpha=0.5,
zorder=2)
ax.add_patch(patch)
patch = PolygonPatch(p2,
facecolor='#ff3333',
edgecolor='#6699cc',
alpha=0.5,
zorder=2)
ax.add_patch(patch)
ax.set_xlim(-1, 3)
ax.set_xticks(range(-1, 4))
ax.set_ylim(-1, 3)
ax.set_yticks(range(-1, 4))
def test_patch(self):
patch = PolygonPatch(self.thing)
self.failUnlessEqual(str(type(patch)),
"<class 'matplotlib.patches.PathPatch'>")
path = patch.get_path()
self.failUnless(len(path.vertices) == len(path.codes) == 330)
def data_visualisation( nb_clust, mask_type, dct_patch, IMG_SIZE, LOD, img_id, terminaison='', namefolder='./',suffixe='', nClassest=2 ):
# print('Total time in seconds:', interval)
term_score = {}
class_color = 0
fig, ax = plt.subplots()
mask_type = load_annotations("./annoWeird.csv", "./anno.csv", img_id, nb_clust, ax)
pred = []
real = []
classesorder = []
for key, ptch in dct_patch.items():
try:
colour = ptch.colour
if colour != -1 :
sh = shapely.geometry.Polygon(
[(ptch.column * ptch.size * LOD, IMG_SIZE[1] * LOD - ptch.row * ptch.size * LOD),
(ptch.column * ptch.size * LOD + ptch.size * LOD, IMG_SIZE[1] * LOD - ptch.row * ptch.size * LOD),
(ptch.column * ptch.size * LOD + ptch.size * LOD,
IMG_SIZE[1] * LOD - ptch.row * ptch.size * LOD + ptch.size * LOD),
(ptch.column * ptch.size * LOD, IMG_SIZE[1] * LOD - ptch.row * ptch.size * LOD + ptch.size * LOD)])
for i, j in mask_type.items():
if j["WKT"].contains(sh): # j["WKT"].intersects(sh): #
if j["Term"] not in term_score:
term_score[j["Term"]] = {}
term_score[j["Term"]]["Predicted"] = []
term_score[j["Term"]]["Patches"] = []
term_score[j["Term"]]["Real"] = class_color
classesorder.append(j["Term"])
class_color += 1
ax.add_patch(PolygonPatch(sh, color=hsv_to_rgb( [colour/ nb_clust, 1, 1])))
j["Clust"][colour].append(colour)
term_score[j["Term"]]["Predicted"].append(colour)
term_score[j["Term"]]["Patches"].append(key)
pred.append(colour)
real.append(term_score[j["Term"]]["Real"])
except KeyError:
pass
# just show the
fig.set_size_inches(30, 15)
plt.title("coloration des zones déjà annotées" + terminaison)
plt.savefig(namefolder + "coloration_zones_annotées_" + terminaison + suffixe + ".png", format="png")
# ax.cla()
print("Pour", nb_clust, "clusters \nARI=", adjusted_mutual_info_score(real, pred), "\nNMI=",
normalized_mutual_info_score(real, pred), "\nhomogenitiy=", )
predt=[]
rt=[]
for i in range(len(pred)):
if real[i] == term_score["tumor"]["Real"]:
predt.append(pred[i])
rt.append(term_score["tumor"]["Real"])
#True positive False_Positive for tumor
maxs=[]
for i in range(nb_clust):
if i in pred:
q=(predt.count(i)/pred.count(i))
if q>0.5:
maxs.append(i)
fsc, sens, spec = 0 ,0 ,0
if maxs:
cptf=0
cptt=0
for i in maxs:
cptt += predt.count(i)
cptf += pred.count(i)
print(maxs)
print(cptt)
print(len(predt))
vp = cptt
fp = cptf - cptt
vn = len(pred) - len(predt) - cptf + cptt
fn = len(predt) - cptt
spec = vn / (vn + fp)
sens = vp / (vp + fn)
fsc =vp/(vp+(fp+fn)/2)
print("vrai positif:", vp)
print("faux positif:", fp )
print("vrai négatif:", vn )
print("faux négatif:",fn)
print("sensibilité:", sens)
print("spécificité:", spec)
print("fscore:", fsc)
classesorder ={}
for k, i in term_score.items():
classesorder[len(i["Predicted"])] = k
print(k, len(i["Predicted"]))
fig, ax = plt.subplots()
fig.set_size_inches(20, 20)
confusion_matrix( pred, real, class_color, nb_clust, ax, list(classesorder.values()))
plt.title("Matrice de confusion" + terminaison)
plt.savefig(namefolder + "Matrice_confusion_" + terminaison +suffixe+ ".png", format="png")
ax.cla()
nb_square = 100
a = [(j["Term"], j) for i, j in mask_type.items()]
rms = []
for i, j in a:
rm = True
for b in j["Clust"]:
if b:
rm = False
break
if rm:
rms.append((i, j))
for r in rms:
a.remove(r)
a = sample(a, k=min(nb_square, len(a)))
a = sorted(a, key=lambda x: x[0])
nb_lines = 5
x = 1
fig, ax = plt.subplots()
for i, j in a:
ax = plt.subplot(nb_lines, nb_square // nb_lines, x)
ax.set_title(j["Term"])
draw_square_xy(j["Clust"], ax)
ax.axis([0, 10, 0, 10])
ax.axis("off")
x += 1
fig.set_size_inches(30, 15)
plt.savefig(namefolder + "coloration_carrés_annotées" + terminaison + suffixe+ ".png", format="png")
plt.close('all')
return adjusted_mutual_info_score(real, pred), fsc
def obstacle_simulation():
"""MISSING DOC
Parameters
----------
Returns
-------
None
"""
start_time = time.time()
# CA properties.
CA_width = 3
CA_length = 67
trials_count = 1000
trial_area_sidelength = 1000
num_of_obstacles = 861
obstacle_width_mu = 17
obstacle_width_sigma = 3
obstacle_length_mu = 8
obstacle_length_sigma = 2
# Booleans to control the computations and visualization
do_compute_coverage = True
do_sanity_check = False
do_theory = True
do_viz = True
do_not_show_CAs = True
do_houses_along_roads = True
OS = Obstacles(CA_width, CA_length, trial_area_sidelength)
gen_polygons_time = time.time()
if do_houses_along_roads:
houses_along_street = 30
rows_of_houses = 15
distance_between_two_houses = 20
OS.generate_rectangular_obstacles_along_curves(obstacle_width_mu, obstacle_width_sigma, obstacle_length_mu,
obstacle_length_sigma, houses_along_street, rows_of_houses,
distance_between_two_houses)
else:
OS.generate_rectangular_obstacles_normal_distributed(num_of_obstacles, obstacle_width_mu, obstacle_width_sigma,
obstacle_length_mu, obstacle_length_sigma)
# Number of obstacles may come from OS, so use that value
obstacle_density = OS.num_of_obstacles / OS.trial_area_sidelength / OS.trial_area_sidelength
OS.generate_CAs(trials_count)
print('Generate polygons time: {:1.3f} sec'.format(time.time() - gen_polygons_time))
# Run trials.
intersection_time = time.time()
OS.compute_reduced_CAs()
OS.compute_CA_lengths()
print('Intersection time: {:1.3f} sec'.format(time.time() - intersection_time))
if do_compute_coverage:
coverage_time = time.time()
OS.compute_coverage()
print('Coverage time: {:1.3f} sec'.format(time.time() - coverage_time))
if do_sanity_check:
sanity_check_time = time.time()
problematic_area, problematic_obstacles, problematic_CAs = OS.sanity_check()
print('Sanity check time: {:1.3f} sec'.format(time.time() - sanity_check_time))
else:
print('Sanity check time: None')
# Compute the probability based on theory.
if do_theory:
theory_time = time.time()
x_resolution = 100
x = np.linspace(0, CA_length, x_resolution)
pdf_resolution = 25
p_x, EX, beta_analytical, sanity_check = OS.cdf(x, obstacle_density, obstacle_width_mu,
obstacle_width_sigma, obstacle_length_mu,
obstacle_length_sigma, pdf_resolution)
print('Theory time: {:1.3f} sec'.format(time.time() - theory_time))
beta_numerical = OS.total_coverage / OS.trial_area_sidelength / OS.trial_area_sidelength
# Create figure for visual output.
viz_time = time.time()
show_CA_as_size = True
fig = plt.figure(1, figsize=(12, 8), dpi=90)
if do_viz:
ax1 = fig.add_subplot(121)
OS.show_simulation(ax1, CAs=(not do_not_show_CAs), CAs_reduced=(not do_not_show_CAs), obstacles_original=True,
obstacles_intersected=(not do_not_show_CAs), CA_first_point=False, debug_points=False)
ax2 = fig.add_subplot(122)
else:
ax2 = fig.add_subplot(111)
OS.show_CDF(ax2, show_CA_as_size)
if do_sanity_check & do_viz:
for o in problematic_obstacles:
ax1.add_patch(PolygonPatch(o, facecolor='#ffff00', edgecolor='#000000', alpha=1, zorder=10, linewidth=0.25))
for CAr in problematic_CAs:
ax1.add_patch(
PolygonPatch(CAr, facecolor='#ffff00', edgecolor='#000000', alpha=1, zorder=10, linewidth=0.25))
print('Visualization time: {:1.3f} sec'.format(time.time() - viz_time))
print('Total time: {:1.3f} sec'.format(time.time() - start_time))
print('---------------------------')
print('Original CA: {:1.0f} m^2'.format(OS.CA_length * OS.CA_width))
print('Average reduced CA: {:1.0f} m^2 ({:d}%)'.format(np.mean(OS.CA_lengths) * OS.CA_width, int(
round(100 * np.mean(OS.CA_lengths) / OS.CA_length))))
print('Analytical reduced CA {:1.0f} m^2'.format(EX * OS.CA_width))
print('---------------------------')
if do_sanity_check:
print('Total intersection area: {:1.0f} m^2 (should be small or zero)'.format(problematic_area))
print('Number of CA reduced: {:d} ({:d}%)'.format(OS.num_of_reduced_CA,
int(round(100 * OS.num_of_reduced_CA / OS.trials_count))))
print('Number of CA empty: {:d} ({:d}%)'.format(OS.num_of_empty_CA,
int(round(100 * OS.num_of_empty_CA / OS.trials_count))))
print('Obstacle density: {:1.0f} #/km^2'.format(obstacle_density * 1E6))
if do_compute_coverage:
print('Obstacle total area: {:1.0f} m^2'.format(OS.total_obstacle_area))
print('Obstacle coverage (num): {:1.0f} m^2'.format(OS.total_coverage))
print('Obstacle coverage (ana): {:1.0f} m^2'.format(
OS.num_of_obstacles * obstacle_width_mu * obstacle_length_mu))
print('Coverage ratio: {:1.3f}'.format(OS.total_coverage / OS.total_obstacle_area))
if do_theory:
print('beta (numerical): {:1.5f}'.format(beta_numerical))
print('beta (analytical): {:1.5f}'.format(beta_analytical))
print('fractiona of empty CA): {:1.3f}'.format(OS.num_of_empty_CA / trials_count))
if do_sanity_check:
print('PDF sanity check: {:1.3f}'.format(sanity_check))
# Show the curve from theory
if do_theory:
if not show_CA_as_size:
ax2.plot(x, p_x, '.', label='Model CDF')
else:
ax2.plot(x * OS.CA_width, p_x, '-', label='Model CDF')
ax2.plot(0, beta_analytical, 'o', color='#00ff00', label='beta anlytical')
ax2.plot(0, beta_numerical, 'o', color='#ff0000', label='beta numerical')
ax2.plot(0, OS.num_of_empty_CA / trials_count, 'o', color='#0000ff', label='Frac of empty CA')
ax2.legend(loc="upper left", )
ax2.grid()
ax2.yaxis.set_ticks(np.arange(0, 1, 0.1))
plt.show()
fig.savefig('Sim_random.png', format='png', dpi=300)
xytext=(0, 8))
fig = pyplot.figure(1, figsize=SIZE, dpi=90)
triangle = Polygon([(1, 1), (2, 3), (3, 1)])
xrange = [0, 5]
yrange = [0, 4]
# 1
ax = fig.add_subplot(121)
patch = PolygonPatch(triangle,
facecolor=GRAY,
edgecolor=GRAY,
alpha=0.5,
zorder=1)
triangle_a = affinity.scale(triangle, xfact=1.5, yfact=-1)
patch_a = PolygonPatch(triangle_a,
facecolor=BLUE,
edgecolor=BLUE,
alpha=0.5,
zorder=2)
ax.add_patch(patch)
ax.add_patch(patch_a)
add_origin(ax, triangle, 'center')
ax.set_title("a) xfact=1.5, yfact=-1")
