def forest(input_forest_raster,
output_file="forest.png",
borders=None,
zoom=None,
figsize=(11.69, 8.27),
dpi=300, **kwargs):
"""Plot forest map.
This function plots the forest map in green value 1 in raster.
:param input_forest_raster: path to forest raster.
:param output_file: name of the plot file.
:param borders: vector file to be plotted.
:param zoom: zoom to region (xmin, xmax, ymin, ymax).
:param figsize: figure size in inches.
:param dpi: resolution for output image.
:return: a Matplotlib figure of the forest map.
"""
# Load raster and band
rasterR = gdal.Open(input_forest_raster)
rasterB = rasterR.GetRasterBand(1)
rasterND = rasterB.GetNoDataValue()
gt = rasterR.GetGeoTransform()
ncol = rasterR.RasterXSize
nrow = rasterR.RasterYSize
Xmin = gt[0]
Xmax = gt[0] + gt[1] * ncol
Ymin = gt[3] + gt[5] * nrow
Ymax = gt[3]
extent = [Xmin, Xmax, Ymin, Ymax]
# Overviews
if (rasterB.GetOverviewCount() == 0):
# Build overviews
print("Build overview")
rasterR.BuildOverviews("nearest", [4, 8, 16, 32])
# Get data from finest overview
ov_band = rasterB.GetOverview(0)
ov_arr = ov_band.ReadAsArray()
ov_arr[ov_arr == rasterND] = 2
# Dereference driver
rasterB = None
del(rasterR)
# Colormap
colors = []
cmax = 255.0 # float for division
colors.append((51 / cmax, 160 / cmax, 44 / cmax, 1)) # forest green
colors.append((0, 0, 0, 0)) # transparent
color_map = ListedColormap(colors)
# Plot raster
place = 111 if zoom is None else 121
fig = plt.figure(figsize=figsize, dpi=dpi)
ax1 = plt.subplot(place)
ax1.set_frame_on(False)
ax1.set_xticks([])
ax1.set_yticks([])
plt.imshow(ov_arr, cmap=color_map, extent=extent)
if borders is not None:
plot_layer(borders, symbol="k-", **kwargs)
plt.axis("off")
if zoom is not None:
z = Rectangle(
(zoom[0], zoom[2]),
zoom[1] - zoom[0],
zoom[3] - zoom[2],
fill=False
)
ax1.add_patch(z)
ax2 = plt.subplot(222)
plt.imshow(ov_arr, cmap=color_map, extent=extent)
plt.xlim(zoom[0], zoom[1])
plt.ylim(zoom[2], zoom[3])
ax2.set_xticks([])
ax2.set_yticks([])
# Save and return figure
fig.tight_layout()
fig.savefig(output_file, dpi="figure", bbox_inches="tight")
return(fig)
# continue rbox = np.array(y_pred[k, :4]) pbox = np.array(y_pred[k, 4:8]) tframe = box2frame(box=pbox, apoint=[0.5, 0.5]) ax.annotate(classes[pclz], (tframe[0], tframe[1]), color='green', weight='bold', fontsize=8, ha='center', va='center') rframe = box2frame(box=rbox, apoint=[0, 0]) tframe = box2frame(box=pbox, apoint=[0, 0]) ax.add_patch(Rectangle( (rframe[0], rframe[1]), rframe[2], rframe[3], linewidth=1, edgecolor='r', facecolor='none', linestyle='-')) ax.add_patch(Rectangle( (tframe[0], tframe[1]), tframe[2], tframe[3], linewidth=1, edgecolor='g', facecolor='none', linestyle='-')) plt.show()
L = 2, 2.7, 3 # room dimensions
x0 = 1.2, 1.7, 1.5 # source position
max_order = 2 # maximum order of image sources
coeffs = .8, .8, .6, .6, .7, .7 # wall reflection coefficients
omega = 2 * np.pi * 1000 # angular frequency of monocromatic sound field
fs = 44100 # sample rate for boadband response
signal = ([1, 0, 0], fs) # signal for broadband response
# get 2D mirror image sources and their strength
xs, wall_count = sfs.util.image_sources_for_box(x0[0:2], L[0:2], max_order)
source_strength = np.prod(coeffs[0:4]**wall_count, axis=1)
# plot mirror image sources
plt.figure()
plt.scatter(*xs.T, source_strength * 20)
plt.gca().add_patch(Rectangle((0, 0), L[0], L[1], fill=False))
plt.xlabel('x / m')
plt.ylabel('y / m')
plt.savefig('image_source_positions.png')
# compute monochromatic sound field
grid = sfs.util.xyz_grid([0, L[0]], [0, L[1]], 1.5, spacing=0.02)
P = sfs.mono.source.point_image_sources(omega,
x0, [1, 0, 0],
grid,
L,
max_order,
coeffs=coeffs)
# plot monocromatic sound field
plt.figure()
sfs.plot.soundfield(P, grid, xnorm=[L[0] / 2, L[1] / 2, L[2] / 2])
def cell_plot(self, i, analysis_tree, decorate=True, **kwargs):
"""
plots the `Partition` for unit roi *i*.
"""
if isinstance(i, str):
label = i
title = kwargs.pop("title", label)
else:
label = self.subset_label(i)
title = kwargs.pop("title", self.roi_label(i))
if "delaunay" not in kwargs:
# anticipate future changes in `helper.tessellation.cell_plot`
voronoi = kwargs.pop("voronoi", dict(centroid_style=None))
kwargs["voronoi"] = voronoi
if "aspect" not in kwargs:
kwargs["aspect"] = "equal"
plot_bb = decorate and self.overlaps(i)
if True: # plot_bb:
kwargs["show"] = False
#
cell_plot(analysis_tree, label=label, title=title, **kwargs)
#
if decorate:
if "axes" in kwargs:
ax = kwargs["axes"]
else:
import matplotlib.pyplot as plt
ax = plt.gca()
_min, _max = self.bounding_box[i]
x0, y0, x1, y1 = _min[0], _min[1], _max[0], _max[1]
xl, yl = ax.get_xlim(), ax.get_ylim()
xc, yc = 0.5 * (x0 + x1), 0.5 * (y0 + y1)
if not plot_bb:
x0, y0, x1, y1 = xl[0], yl[0], xl[1], yl[1]
ax.plot(
[x0, x1, np.nan, xc, xc],
[yc, yc, np.nan, y0, y1],
color="k",
linestyle="--",
alpha=1,
linewidth=1,
)
if plot_bb:
from matplotlib.collections import PatchCollection
from matplotlib.patches import Rectangle
masks = []
if xl[0] < x0:
masks.append(Rectangle((xl[0], yl[0]), x0 - xl[0], yl[1] - yl[0]))
if x1 < xl[1]:
masks.append(Rectangle((x1, yl[0]), xl[1] - x1, yl[1] - yl[0]))
if yl[0] < y0:
masks.append(Rectangle((x0, yl[0]), x1 - x0, y0 - yl[0]))
if y1 < yl[1]:
masks.append(Rectangle((x0, y1), x1 - x0, yl[1] - y1))
pc = PatchCollection(masks, facecolor="k", alpha=0.1, edgecolor=None)
ax.add_collection(pc)
#
ax.plot(
[x0, x0, x1, x1, x0],
[y0, y1, y1, y0, y0],
color="k",
linestyle="-",
alpha=1,
linewidth=1,
)
ax.set_xlim(xl)
ax.set_ylim(yl)
def __init__(self, transform, size, label, loc,
pad=0.1, borderpad=0.1, sep=2,
frameon=True, size_vertical=0, color='black',
label_top=False, fontproperties=None, fill_bar=None,
**kwargs):
"""
Draw a horizontal scale bar with a center-aligned label underneath.
Parameters
----------
transform : `matplotlib.transforms.Transform`
The transformation object for the coordinate system in use, i.e.,
:attr:`matplotlib.axes.Axes.transData`.
size : float
Horizontal length of the size bar, given in coordinates of
*transform*.
label : str
Label to display.
loc : int
Location of this size bar. Valid location codes are::
'upper right' : 1,
'upper left' : 2,
'lower left' : 3,
'lower right' : 4,
'right' : 5,
'center left' : 6,
'center right' : 7,
'lower center' : 8,
'upper center' : 9,
'center' : 10
pad : float, default: 0.1
Padding around the label and size bar, in fraction of the font
size.
borderpad : float, default: 0.1
Border padding, in fraction of the font size.
sep : float, default: 2
Separation between the label and the size bar, in points.
frameon : bool, default: True
If True, draw a box around the horizontal bar and label.
size_vertical : float, default: 0
Vertical length of the size bar, given in coordinates of
*transform*.
color : str, default: 'black'
Color for the size bar and label.
label_top : bool, default: False
If True, the label will be over the size bar.
fontproperties : `matplotlib.font_manager.FontProperties`, optional
Font properties for the label text.
fill_bar : bool, optional
If True and if size_vertical is nonzero, the size bar will
be filled in with the color specified by the size bar.
Defaults to True if `size_vertical` is greater than
zero and False otherwise.
**kwargs
Keyworded arguments to pass to
:class:`matplotlib.offsetbox.AnchoredOffsetbox`.
Attributes
----------
size_bar : `matplotlib.offsetbox.AuxTransformBox`
Container for the size bar.
txt_label : `matplotlib.offsetbox.TextArea`
Container for the label of the size bar.
Notes
-----
If *prop* is passed as a keyworded argument, but *fontproperties* is
not, then *prop* is be assumed to be the intended *fontproperties*.
Using both *prop* and *fontproperties* is not supported.
Examples
--------
>>> import matplotlib.pyplot as plt
>>> import nump as np
>>> from mpl_toolkits.axes_grid1.anchored_artists import (
... AnchoredSizeBar)
>>> fig, ax = plt.subplots()
>>> ax.imshow(np.random.random((10, 10)))
>>> bar = AnchoredSizeBar(ax.transData, 3, '3 data units', 4)
>>> ax.add_artist(bar)
>>> fig.show()
Using all the optional parameters
>>> import matplotlib.font_manager as fm
>>> fontprops = fm.FontProperties(size=14, family='monospace')
>>> bar = AnchoredSizeBar(ax.transData, 3, '3 units', 4, pad=0.5,
... sep=5, borderpad=0.5, frameon=False,
... size_vertical=0.5, color='white',
... fontproperties=fontprops)
"""
if fill_bar is None:
fill_bar = size_vertical > 0
self.size_bar = AuxTransformBox(transform)
self.size_bar.add_artist(Rectangle((0, 0), size, size_vertical,
fill=fill_bar, facecolor=color,
edgecolor=color))
if fontproperties is None and 'prop' in kwargs:
fontproperties = kwargs.pop('prop')
if fontproperties is None:
textprops = {'color': color}
else:
textprops = {'color': color, 'fontproperties': fontproperties}
self.txt_label = TextArea(
label,
minimumdescent=False,
textprops=textprops)
if label_top:
_box_children = [self.txt_label, self.size_bar]
else:
_box_children = [self.size_bar, self.txt_label]
self._box = VPacker(children=_box_children,
align="center",
pad=0, sep=sep)
AnchoredOffsetbox.__init__(self, loc, pad=pad, borderpad=borderpad,
child=self._box,
prop=fontproperties,
frameon=frameon, **kwargs)
# for plot import matplotlib.pyplot as plt plt.ion() fig = plt.figure() #plt.figure(figsize=(20,7)) x = np.arange(n) x2 = np.arange(naux) ax1 = fig.add_subplot(3,1,1) line1, = ax1.plot(x, np.zeros(n, dtype=np.float32), linestyle='None', marker='p', markersize=2) ax1.set_xlim(0, nx) ax1.set_ylim(-1.2, 1.2) from matplotlib.patches import Rectangle rect = Rectangle((spt1, -1.2), spt2-spt1, 2.4, facecolor='w', linestyle='dashed') ax1.add_patch(rect) ax2 = fig.add_subplot(3,1,2) line2, = ax2.plot(x2, np.zeros(naux, dtype=np.float32), linestyle='None', marker='p', markersize=2) ax2.set_xlim(0, naux) ax2.set_ylim(-1.2, 1.2) ax3 = fig.add_subplot(3,1,3) line3, = ax3.plot(x2, np.zeros(naux, dtype=np.float32), linestyle='None', marker='p', markersize=2) ax3.set_xlim(0, naux) ax3.set_ylim(-1.2, 1.2) # main loop for tstep in xrange(tmax):
def multi_van_krevelen_plot(*formula_lists,
group_labels = [],
colours=[],
symbols=[],
alphas = [],
edge_colours = [],
x_ratio = 'OC',
y_ratio = 'HC',
patch_classes = [],
patch_alpha = 0.3,
patch_colors = ['#762a83','#9970ab','#c2a5cf','#e7d4e8','#d9f0d3','#a6dba0','#5aae61','#1b7837'],
patch_text = True,
**kwargs):
"""
Docstring for function PyKrev.multi_van_krevelen_plot
====================
This function takes multiple lists of molecula formula strings and plots a van Krevelen diagram.
Use
----
multi_van_krevelen_plot(*Y)
Returns tuple containing figure and axes handles
Parameters
----------
*Y: multiple lists of molecular formula strings.
group_labels: A list of strings corresponding to each formula_list in Y to be displayed in the legend.
colours: A list of strings providing marker colours corresponding to each formula_list in Y.
See: https://matplotlib.org/2.1.1/api/_as_gen/matplotlib.pyplot.plot.html
symbol: A list of scatter plot symbols to use corresponding to each formula_list in Y.
See: https://matplotlib.org/3.2.1/api/markers_api.html
edge_colours: a list of strings providing marker edge colours corresponding to each formula_list in Y.
alphas: list of floats providing transparency of the marker points corresponding to each formula_list in Y.
x_ratio: element ratio to plot on x axis, given numerator denominator e.g. 'OC'
y_ratio: element ratio to plot on y axis, given numerator denominator e.g. 'HC'
patch_classes: a list of the compound classes boundaries (taken from formularity software) to overlay as patches, can include:
'lipid-like'
'carbohydrate-like'
'unsaturated hydrocarbons'
'condensed aromatics'
'lignin-like'
'tannin-like'
'amino sugar-like'
'protein-like'
patch_alpha: the transparency of the compound class (float between 0 and 1)
patch_colors: hex values for the colors of each class in patch_classes
patch_text: boolean, include text labels on the compound class patches
**kwargs: other key word arguments to pass to plt.scatter()
"""
if len(formula_lists) == 1: formula_lists = formula_lists[0] #this enables the user to pass a nested set of lists
assert 'alpha' not in kwargs, 'provide a list of alpha values, alphas = ...'
assert 'c' not in kwargs, 'provide a list of colour values, colours = ...'
assert 'color' not in kwargs, 'provide a list of color values, colours = ...'
assert 'marker' not in kwargs, 'provide a list of marker values, symbols = ...'
assert 'edgecolors' not in kwargs, 'provide a list of edgecolors, edge_colours = ...'
assert 'label' not in kwargs, 'provide a list of labels, group_labels = ...'
#apply colour blind safe colors taken from https://colorbrewer2.org/
cols = ['#7fc97f','#beaed4','#fdc086','#74add1','#fdae61','#abd9e9','#fee090','#e0f3f8','#ffffbf']
sybls = ['o','X','s','D','+','1','^','v','8']
if not group_labels:
group_labels = ['NA'] * len(formula_lists)
if not colours:
colours = [cols[i] for i in range(0,len(formula_lists))]
if not symbols:
symbols = [sybls[i] for i in range(0,len(formula_lists))]
if not alphas:
alphas = [0.5] * len(formula_lists)
if not edge_colours:
edge_colours = ['None'] * len(formula_lists)
assert len(formula_lists) == len(group_labels) == len(colours) == len(symbols) == len(alphas) == len(edge_colours), 'Input variables must all be the same length'
i = 0
for formula_list in formula_lists:
x_axis = []
y_axis = []
ratio_list = element_ratios(formula_list, ratios = [x_ratio,y_ratio])
for ratios in ratio_list:
x_axis.append(ratios[x_ratio])
y_axis.append(ratios[y_ratio])
plt.scatter(x_axis, y_axis, alpha=alphas[i], edgecolors=edge_colours[i],c=colours[i], marker = symbols[i], label = group_labels[i], **kwargs)
i += 1
#apply grid lines
plt.grid(True)
#add on chemical class patches
#boundaries taken from formularity software
assert len(patch_colors) >= len(patch_classes), "Provide at least as many colors as classes"
cindx = 0 #index for the patch colours
if 'lipid-like' in patch_classes:
plt.gca().add_patch(Rectangle((0.01,1.5),0.29,0.7,linewidth=2,edgecolor =patch_colors[cindx],facecolor=patch_colors[cindx],alpha = patch_alpha))
if patch_text: plt.text(0.012,2.14,'Lipid',fontsize=11,alpha=1, color = 'k')
cindx += 1
if 'carbohydrate-like' in patch_classes:
plt.gca().add_patch(Rectangle((0.7,1.5),0.4,0.8,linewidth=2,edgecolor =patch_colors[cindx],facecolor=patch_colors[cindx],alpha = patch_alpha))
if patch_text: plt.text(0.702,2.24,'Carbs',fontsize=11,alpha=1, color = 'k')
cindx += 1
if 'unsaturated hydrocarbons' in patch_classes:
plt.gca().add_patch(Rectangle((0.01,0.8),0.09,0.7,linewidth=2,edgecolor =patch_colors[cindx],facecolor=patch_colors[cindx],alpha = patch_alpha))
if patch_text: plt.text(0.012,1.44,'Unsat HC',fontsize=11,alpha=1, color = 'k')
cindx += 1
if 'condensed aromatics' in patch_classes:
plt.gca().add_patch(Rectangle((0.01,0.2),0.09,0.6,linewidth=2,edgecolor =patch_colors[cindx],facecolor=patch_colors[cindx],alpha = patch_alpha))
if patch_text: plt.text(0.012,0.74,'Con HC',fontsize=11,alpha=1, color = 'k')
cindx += 1
if 'lignin-like' in patch_classes:
plt.gca().add_patch(Rectangle((0.1,0.8),0.6,0.8,linewidth=2,edgecolor =patch_colors[cindx],facecolor=patch_colors[cindx],alpha = patch_alpha))
if patch_text: plt.text(0.102,1.54,'Lignin',fontsize=11,alpha=1, color = 'k')
cindx += 1
if 'tannin-like' in patch_classes:
plt.gca().add_patch(Rectangle((0.7,0.8),0.5,0.8,linewidth=2,edgecolor =patch_colors[cindx],facecolor=patch_colors[cindx],alpha = patch_alpha))
if patch_text: plt.text(0.702,1.54,'Tannin',fontsize=11,alpha=1, color = 'k')
cindx += 1
if 'amino sugar-like' in patch_classes:
plt.gca().add_patch(Rectangle((0.6,1.5),0.1,0.7,linewidth=2,edgecolor =patch_colors[cindx],facecolor=patch_colors[cindx],alpha = patch_alpha))
if patch_text: plt.text(0.602,2.14,'AminoSugar',fontsize=11,alpha=1, color = 'k')
cindx += 1
if 'protein-like' in patch_classes:
plt.gca().add_patch(Rectangle((0.3,1.5),0.3,0.8,linewidth=2,edgecolor =patch_colors[cindx],facecolor=patch_colors[cindx],alpha = patch_alpha))
if patch_text: plt.text(0.302,2.24,'Protein',fontsize=11,alpha=1, color = 'k')
cindx += 1
#label axis
plt.xlabel(f"Atomic ratio of {x_ratio[0]}/{x_ratio[1]}")
plt.ylabel(f"Atomic ratio of {y_ratio[0]}/{y_ratio[1]}")
fig = plt.gcf()
ax = plt.gca()
return fig,ax
maxBSReceives = 8
#maxX = 2 * maxDist * math.sin(60*(math.pi/180)) # == sqrt(3) * maxDist
maxX = 5 * maxDist * math.sin(60 * (math.pi / 180))
print "maxX ", maxX
#maxY = 2 * maxDist * math.sin(30*(math.pi/180)) # == maxdist
maxY = 5 * maxDist * math.sin(30 * (math.pi / 180))
print "maxY", maxY
# prepare graphics and add sink
if (graphics == 1):
plt.ion()
plt.figure()
ax = plt.gcf().gca()
ax.add_patch(Rectangle((0, 0), maxX, maxY, fill=None, alpha=1))
## Après optimisation du placement des bs
#On place juste les nodes sans créer de paquets virtuels (car ils dépendent de la position des bs)
for i in range(0, nrNodes):
# myNode takes period (in ms), base station id packetlen (in Bytes)
# 1000000 = 16 min
node = myNode(i, avgSendTime, 20)
node.placeNode(i)
node.draw(i)
nodes.append(node)
###MEAN SHIFT PART
original_X = node_positions
original_X = np.copy(original_X)
ax.set_ylim(0, pow(2, 16) - 1)
#ax.scatter(figsize=(12,12))
ax.scatter(x, y, facecolor='black', s=1, alpha=0.2)
print('Printing cells...')
for i, r in dfr.iterrows():
cid = int(r['id'])
if cid != -2:
c = 'C{}'.format(cid)
#print(c)
rect = Rectangle((r['x'], r['y']),
r['s'],
r['s'],
edgecolor='gray',
facecolor=c,
alpha=0.25)
ax.add_patch(rect)
else:
c = 'C{}'.format(cid)
rect = Circle((r['x'], r['y']),
300,
edgecolor='red',
facecolor='None',
alpha=1)
ax.add_patch(rect)
plt.show()
print('Done.')
def is_match(known_embedding, candidate_embedding):
# calculate distance between embeddings
score = cosine(known_embedding, candidate_embedding)
return score
thresh = 0.35 #means looking for at least 65% similarity
print("Please note this machine only knows prashant")
group_array = plt.imread(group_photo)
plt.imshow(group_array)
for i in range(0, len(group_embedding)):
pk_score = is_match(known_embedings[0], group_embedding[i])
if pk_score < thresh:
ax = plt.gca()
x = face_coordinates[i][0]
y = face_coordinates[i][1]
width = face_coordinates[i][2]
height = face_coordinates[i][3]
rect = Rectangle((x, y), width, height, fill=False, color='red')
ax.add_patch(rect)
s = str((100 - pk_score * 100))
ax.text(x, y, 'Prashant - ' + s, color='yellow')
plt.show()
model = VGGFace()
print(model.summary())
def evolucionar(self,
iteraciones: int,
porcentaje_conv: float = 1.0,
retornar_gen=False):
"""
Hace que la población evolucione, es decir, que se avance cierta cantidad de generaciones.
Además del valor retornato, este método da las siguientes salidas:
1.- Una gráfica donde se visualiza la evolución de la media, el mejor caso y el peor caso,
de los valores de fitness, para todas las generaciones, antes de realizar la poda.
2.- Una imagen donde se aprecia el escenario y el recorrido del mejor individuo de la última generación.
:param iteraciones: Por cuántas generaciones se va a avanzar.
:param porcentaje_conv: En qué porcentaje deben converger los mejores individuos de una generación,
para cancelar el resto de las iteraciones.
:param retornar_gen: (Opcional) Si es True, la cantidad de iteraciones que se llevaron a cabo y
no se graficará nada.
:return: La información del individuo más apto de la última generación.
"""
if iteraciones < 1:
raise ValueError('Valor de iteraciones erróneo.')
elif not (0.0 < porcentaje_conv <= 1.0):
raise ValueError(
'El porcentaje de convergencia debe estar en el rango (0,1].')
# Valores de fitness a graficar por cada iteración.
minimos, maximos, promedios = [], [], []
# Se guardan los datos estadísticos de la generación inicial.
self.actualizar_salida_grafica(minimos, maximos, promedios)
# Las generaciones avanzan.
for i in range(1, iteraciones + 1):
self.cruzar() # 'mutar' es mandado a llamar por 'cruzar'.
self.actualizar_salida_grafica(minimos, maximos, promedios)
self.podar()
# Se extraen los valores de fitness.
fitnesses = [
individuo.get_fitness() for individuo in self.poblacion
]
''' Si al menos, el porcentaje de individuos, especificado en 'porcentaje_conv',
tienen el mejor valor de fitness (que no tenga ningún obstáculo/penalización);
se considera que ya se ha convergido a la solución óptima,
por lo que ya no es necesario seguir iterando.
Este chequeo se realiza, una vez, se haya llegado a la polbación máxima.'''
if ((len(fitnesses) == self.tam_pob_max)
and (min(fitnesses) < self.penalizacion)
and ((fitnesses.count(min(fitnesses)) / len(fitnesses)) >=
porcentaje_conv)):
break
#print('Generación: {!s} - Población: {!s}'.format(i, len(fitnesses)))
if retornar_gen:
return i
# El mejor individuo de la generación más reciente.
mejor_ind = self.poblacion[-1]
'''
SE GRAFICAN LOS DATOS ESTADÍSTICOS DE LOS FITNESS.
'''
plt.clf() # Se eliminan gráficas pasadas.
# Se crea el arraglo con los valores del eje x.
indices_iteraciones = np.arange(0, i + 1)
# Se grafican los valores máximos, mínimos y los promedios.
plt.plot(indices_iteraciones, maximos, lw=2, label='Peor caso')
plt.plot(indices_iteraciones, minimos, lw=2, label='Mejor caso')
plt.plot(indices_iteraciones, promedios, lw=2, label='Promedio')
plt.legend()
# Se agregan las etiquetas de los ejes y el título.
plt.xlabel('Generación/Iteración')
plt.ylabel('Fitness')
plt.title('Evolución de los valores de fitness (antes de la poda)')
# Se muestra una cuadrícula.
plt.grid(True)
'''
SE GRAFICA EL ESCENARIO CON EL CAMINO DEL MEJOR INDIVIDUO DE LA ÚLTIMA GENERACIÓN.
'''
# Fenotipo del mejor individuo, el recorrido representado por él.
fen_mejor_ind = mejor_ind.get_fenotipo()
# Las coordenadas de los puntos, separadas por ejes.
x_camino, y_camino = [], []
for i in range(0, len(fen_mejor_ind), 2):
x_camino.append(fen_mejor_ind[i])
y_camino.append(fen_mejor_ind[i + 1])
# Los obstáculos, como rectángulos, para ser graficados.
rec_obstaculos = []
for obst in self.escenario['obstaculos']:
# Se guarda el obstáculo, como un rectángulo que puede ser graficado por Matplotlib.
rec_obstaculos.append(
Rectangle((obst['x'], obst['y']), obst['anchura'],
obst['altura']))
fig, ax = plt.subplots()
# Se grafican los obstáculos.
pc = PatchCollection(rec_obstaculos, facecolor='black')
ax.add_collection(pc)
# Se grafica el camino del mejor individuo.
ax.plot(x_camino, y_camino, marker='o')
ax.plot(x_camino[0], y_camino[0], 'gX', label='Inicio')
ax.plot(x_camino[-1], y_camino[-1], 'rX', label='Fin')
# Se limitan los ejes.
plt.xlim(0, self.escenario['tamano']['anchura'])
plt.ylim(0, self.escenario['tamano']['altura'])
# Se dibuja la cuadrícula.
loc = plticker.MultipleLocator(base=1)
ax.xaxis.set_major_locator(loc)
ax.yaxis.set_major_locator(loc)
# Se titula la gráfica.
ax.set_title('Recorrido del mejor individuo de la última generación')
# Se muestra la gráfica.
plt.grid(True)
plt.legend()
plt.show()
# Se devuelve la información del individuo más apto.
return str(mejor_ind)
def plot_simulation(simulated,
camera_output,
fiber=0,
wavelength_min=None,
wavelength_max=None,
title=None,
min_electrons=2.5,
figsize=(11, 8.5),
label_size='medium'):
"""Plot simulation output tables for a single fiber.
This function is normally called via :meth:`Simulator.plot` but is provided
separately so that plots can be generated from results saved to a file.
Use :meth:`show <matplotlib.pyplot.show` and :meth:`savefig
<matplotlib.pyplot.savefig>` to show or save the resulting plot.
See :doc:`/cmdline` for a sample plot.
Requires that the matplotlib package is installed.
Parameters
----------
simulated : astropy.table.Table
Simulation results on the high-resolution simulation wavelength grid.
camera_output : list
Lists of tables of per-camera simulation results tabulated on each
camera's output pixel grid.
fiber : int
Fiber index to plot.
wavelength_min : quantity or None
Clip the plot below this wavelength, or show the full extent.
wavelength_max : quantity or None
Clip the plot above this wavelength, or show the full extent.
title : str or None
Descriptive title to use for the plot.
min_electrons : float
Minimum y-axis value for displaying numbers of detected electrons.
figsize : tuple
Tuple (width, height) specifying the figure size to use in inches.
See :meth:`matplotlib.pyplot.subplots` for details.
"""
import matplotlib.pyplot as plt
from matplotlib.patches import Rectangle
fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=figsize, sharex=True)
if title is not None:
ax1.set_title(title)
waveunit = '{0:Generic}'.format(simulated['wavelength'].unit)
fluxunit = '{0:Generic}'.format(simulated['source_flux'].unit)
wave = simulated['wavelength'].data
dwave = np.gradient(wave)
# Validate the optional wavelength limits and convert to waveunit.
def validate(name, limit):
if limit is None:
return limit
try:
return limit.to(waveunit).value
except AttributeError:
raise ValueError('Missing unit for {0}.'.format(name))
except u.UnitConversionError:
raise ValueError('Invalid unit for {0}.'.format(name))
wavelength_min = validate('wavelength_min', wavelength_min)
wavelength_max = validate('wavelength_max', wavelength_max)
if wavelength_min and wavelength_max and wavelength_min >= wavelength_max:
raise ValueError('Expected wavelength_min < wavelength_max.')
# Create a helper function that returns a slice that limits the
# wavelength array w (with units) to wavelenth_min <= w <= wavelength_max.
# Returns None if all w < wavelength_min or all w > wavelength_max.
def get_slice(w):
assert np.all(np.diff(w) > 0)
if wavelength_min is None:
start = 0
elif wavelength_min > w[-1]:
return None
else:
start = np.where(w >= wavelength_min)[0][0]
if wavelength_max is None:
stop = len(w)
elif wavelength_max < w[0]:
return None
else:
stop = np.where(w <= wavelength_max)[0][-1] + 1
return slice(start, stop)
# Trim the full wavelength grid.
waves = get_slice(wave)
if waves is None:
raise ValueError('Wavelength limits do not overlap simulation grid.')
wave = wave[waves]
dwave = dwave[waves]
# Plot fluxes above the atmosphere and into the fiber.
src_flux = simulated['source_flux'][waves, fiber]
src_fiber_flux = simulated['source_fiber_flux'][waves, fiber]
sky_fiber_flux = simulated['sky_fiber_flux'][waves, fiber]
ymin, ymax = 0.1 * np.min(src_flux), 10. * np.max(src_flux)
if ymin <= 0:
# Need ymin > 0 for log scale.
ymin = 1e-3 * ymax
line, = ax1.plot(wave, src_flux, 'r-')
ax1.fill_between(wave,
src_fiber_flux + sky_fiber_flux,
ymin,
color='b',
alpha=0.2,
lw=0)
ax1.fill_between(wave, src_fiber_flux, ymin, color='r', alpha=0.2, lw=0)
# This kludge is because the label arg to fill_between() does not
# propagate to legend() in matplotlib < 1.5.
sky_fill = Rectangle((0, 0), 1, 1, fc='b', alpha=0.2)
src_fill = Rectangle((0, 0), 1, 1, fc='r', alpha=0.2)
ax1.legend(
(line, sky_fill, src_fill),
('Source above atmosphere', 'Sky into fiber', 'Source into fiber'),
loc='best',
fancybox=True,
framealpha=0.5,
ncol=3,
fontsize=label_size)
ax1.set_ylim(ymin, ymax)
ax1.set_yscale('log')
ax1.set_ylabel('Flux [{0}]'.format(fluxunit))
# Plot numbers of photons into the fiber.
nsky = simulated['num_sky_photons'][waves, fiber] / dwave
nsrc = simulated['num_source_photons'][waves, fiber] / dwave
nmax = np.max(nsrc)
ax2.fill_between(wave,
nsky + nsrc,
1e-1 * nmax,
color='b',
alpha=0.2,
lw=0)
ax2.fill_between(wave, nsrc, 1e-1 * nmax, color='r', alpha=0.2, lw=0)
ax2.legend((sky_fill, src_fill), ('Sky into fiber', 'Source into fiber'),
loc='best',
fancybox=True,
framealpha=0.5,
ncol=2,
fontsize=label_size)
ax2.set_ylim(1e-1 * nmax, 10. * nmax)
ax2.set_yscale('log')
ax2.set_ylabel('Mean photons / {0}'.format(waveunit))
ax2.set_xlim(wave[0], wave[-1])
# Plot numbers of electrons detected by each CCD.
for output in camera_output:
cwave = output['wavelength'].data
dwave = np.gradient(cwave)
# Trim to requested wavelength range.
waves = get_slice(cwave)
if waves is None:
# Skip any cameras outside the requested wavelength range.
continue
cwave = cwave[waves]
dwave = dwave[waves]
nsky = output['num_sky_electrons'][waves, fiber] / dwave
nsrc = output['num_source_electrons'][waves, fiber] / dwave
ndark = output['num_dark_electrons'][waves, fiber] / dwave
read_noise = (output['read_noise_electrons'][waves, fiber] /
np.sqrt(dwave))
total_noise = (np.sqrt(output['variance_electrons'][waves, fiber] /
dwave))
nmax = max(nmax, np.max(nsrc))
ax3.fill_between(cwave,
ndark + nsky + nsrc,
min_electrons,
color='b',
alpha=0.2,
lw=0)
ax3.fill_between(cwave,
ndark + nsrc,
min_electrons,
color='r',
alpha=0.2,
lw=0)
ax3.fill_between(cwave,
ndark,
min_electrons,
color='k',
alpha=0.2,
lw=0)
ax3.scatter(cwave, total_noise, color='k', lw=0., s=0.5, alpha=0.5)
line2, = ax3.plot(cwave, read_noise, color='k', ls='--', alpha=0.5)
if camera_output:
# This kludge is because the label arg to fill_between() does not
# propagate to legend() in matplotlib < 1.5.
line1, = ax3.plot([], [], 'k-')
dark_fill = Rectangle((0, 0), 1, 1, fc='k', alpha=0.2)
ax3.legend((sky_fill, src_fill, dark_fill, line1, line2),
('Sky detected', 'Source detected', 'Dark current',
'RMS total noise', 'RMS read noise'),
loc='best',
fancybox=True,
framealpha=0.5,
ncol=5,
fontsize=label_size)
ax3.set_ylim(min_electrons, 2e2 * min_electrons)
ax3.set_yscale('log')
ax3.set_ylabel('Mean electrons / {0}'.format(waveunit))
ax3.set_xlim(wave[0], wave[-1])
ax3.set_xlabel('Wavelength [{0}]'.format(waveunit))
# Remove x-axis ticks on the upper panels.
plt.setp([a.get_xticklabels() for a in fig.axes[:-1]], visible=False)
fig.patch.set_facecolor('white')
plt.tight_layout()
def updatePlot(self, poles, cable, printPdf=False):
scale = 1
legendCol = 4
fontSize = 12
if printPdf:
legendCol = 3
scale = 0.5
fontSize = 8
# current Zoom
xlim = self.axes.get_xlim()
ylim = self.axes.get_ylim()
self.axes.clear()
self.__setupAxes()
# Terrain
self.axes.plot(self.xdata, self.terrain, color='#a1d1ab',
linewidth=3.5*scale, zorder=1)
# Mark survey points when working with CSV height data
if self.tPoints is not None:
# Add markers for survey points
for pointX, pointY, idx, notes in zip(self.tPoints['d'],
self.tPoints['z'],
self.tPoints['nr'],
self.tPoints['notes']):
self.axes.plot([pointX, pointX],
[pointY, pointY - 6 * self.labelBuffer * scale],
color='green', linewidth=1.5 * scale, zorder=2)
labelText = f"{idx}"
rot = 0
ha = 'center'
va = 'top'
if notes:
labelText = f"{idx}{':' if notes else ''} {notes if len(notes) <= 25 else notes[:22] + '...'}"
# For less placement issues, labels are rotated 45°
rot = 55
ha = 'right'
va = 'center'
# Label rotation is switched if profile line inclines
if self.terrain[0] < self.terrain[-1]:
rot = 305
ha = 'left'
self.axes.text(pointX, pointY - 7 * self.labelBuffer * scale,
labelText, ha=ha, va=va, fontsize=fontSize,
color='green', rotation=rot, rotation_mode='anchor')
if not printPdf:
# Well suited locations (peaks) for poles
self.axes.scatter(self.peakLoc_x, self.peakLoc_y, marker='^',
color='#ffaa00', edgecolors='#496b48',
label=self.tr('Guenstige Gelaendeform'), zorder=3)
# Cable lines
self.axes.plot(cable['xaxis'], cable['empty'], color='#4D83B2',
linewidth=1.5*scale, label=self.tr('Leerseil'))
self.axes.plot(cable['xaxis'], cable['load'], color='#FF4D44',
linewidth=1.5*scale, label=self.tr('Lastwegkurve nach Zweifel'))
# Anchors
if cable['anchorA']:
self.axes.plot(cable['anchorA']['d'], cable['anchorA']['z'],
color='#a6a6a6', linewidth=1.5*scale)
if cable['anchorE']:
self.axes.plot(cable['anchorE']['d'], cable['anchorE']['z'],
color='#a6a6a6', linewidth=1.5*scale)
# Ground clearance
self.axes.plot(cable['groundclear_di'], cable['groundclear'],
color='#910000', linewidth=1*scale, linestyle=':',
label=self.tr('Min. Bodenabstand'))
self.axes.plot(cable['groundclear_di'], cable['groundclear_under'],
color='#910000', linewidth=1*scale)
# Poles
[pole_d, pole_z, pole_h, pole_dtop, pole_ztop, pole_nr, poleType] = poles
for i, d in enumerate(pole_d):
self.axes.plot([pole_d[i], pole_dtop[i]], [pole_z[i], pole_ztop[i]],
color='#363432', linewidth=3.0*scale)
if poleType[i] == 'crane':
h = 3.5
w = h * 1.8
rect = Rectangle((pole_d[i] - w/2, pole_z[i]), w, h, ls='-',
lw=3.0*scale, facecolor='black', ec='black', zorder=5)
self.axes.add_patch(rect)
# Vertical guide lines
if self.isZoomed:
d = self.currentPole['d']
z = self.currentPole['z']
ztop = self.currentPole['ztop']
self.axes.axvline(lw=1, ls='dotted', color='black', x=d)
self.axes.axhline(lw=1, ls='dotted', color='black', y=z)
self.axes.axhline(lw=1, ls='dotted', color='black', y=ztop)
# Data limit of axis
# self.setPlotLimits()
# Add labels
if not printPdf:
self.placeLabels(pole_dtop, pole_ztop, pole_nr)
# Legend
self.axes.legend(loc='lower center', fontsize=fontSize,
bbox_to_anchor=(0.5, 0), ncol=legendCol)
self.axes.set_xlim(xlim)
self.axes.set_ylim(ylim)
self.draw()
# Set new plot extent as home extent (for home button)
if not printPdf:
self.tbar.update()
self.tbar.push_current()
def draw_heatmap_obim(
result_image_name,
input_files,
baseline_files,
titles,
small_delta,
xcolticks=[],
ycolticks=[],
):
fig, axn = plt.subplots(2, len(input_files), sharey='row')
file_mul = .32
cbar_ax = fig.add_axes([ file_mul * len(input_files) + .11, 0.73, .03, .35])
cbar_ax2 = fig.add_axes([ file_mul * len(input_files) + .11, 0.17, .03, .35])
ticks_delta = [0.5, 1.5, 2.5, 3.5, 4.5]
ticks_chunks = [0.5, 1.5, 2.5, 3.5, 4.5]
deltas = [0, 2, 4, 8, 10] if small_delta else [10, 12, 14, 16, 18]
chunks = ['$2^{5}$', '$2^{6}$', '$2^{7}$', '$2^{8}$', '$2^{9}$']
max_t = 0
min_t = 1000
max_n = 0
min_n = 1000
for i, file in enumerate(input_files):
(time_hmq, nodes_hmq) = find_avg_hmq(baseline_files[i])
#print(time_div, nodes_div)
(hm, hm_n) = obimheatmap2array(file, time_hmq, nodes_hmq, small_delta)
max_t_id_i = 0
max_t_id_j = 0
max_t_local = 0
for k in range(0, len(hm)):
for j in range(0, len(hm[k])):
val = hm[k][j]
if val > max_t:
max_t = val
if val > max_t_local:
max_t_local = val
max_t_id_i = k
max_t_id_j = j
if val < min_t:
min_t = val
if hm_n[k][j] > max_n:
max_n = hm_n[k][j]
if hm_n[k][j] < min_n:
min_n = hm_n[k][j]
cmap = matplotlib.colors.LinearSegmentedColormap.from_list("", ["#990000", "#ffff00", "#38761d"])
cmap2 = matplotlib.colors.LinearSegmentedColormap.from_list("", ["#38761d", "#ffff00", "#990000"])
print(titles[i] + ": {" + str(2 ** max_t_id_j) + ", " + str(2 **max_t_id_i) + "} " + str(hm[max_t_id_i][max_t_id_j]))
fmt = lambda x,pos: '{:.2f}'.format(x)
thm = sns.heatmap(hm, ax=axn[0][i], center=1, cmap=cmap,
vmin=min_t, vmax=max_t, annot=True, fmt=".1f",
linewidths=.7, square=True, cbar_ax=cbar_ax,
cbar_kws={
'format': FuncFormatter(fmt),
'label' : 'Speedup',
'ticks' : [min_t, *xcolticks, max_t]
}
)
nhm = sns.heatmap(hm_n, ax=axn[1][i], center=1, cmap=cmap2,
vmin=min_n, vmax=max_n, annot=True, fmt=".1f",
linewidths=.7, square=True, cbar_ax=cbar_ax2,
cbar_kws={
'format': FuncFormatter(fmt),
'label' : 'Work Increase',
'ticks' : [min_n, *ycolticks, max_n]
}
)
thm.xaxis.set_ticks_position('top')
nhm.xaxis.set_ticks_position('top')
thm.add_patch(Rectangle((max_t_id_j, max_t_id_i), 1, 1, fill=False, edgecolor='black', lw=1.2))
nhm.add_patch(Rectangle((max_t_id_j, max_t_id_i), 1, 1, fill=False, edgecolor='black', lw=1.2))
axn[0][i].set_xticks(ticks_chunks)
axn[1][i].set_xticks(ticks_chunks)
axn[0][i].set_xticklabels(chunks, rotation=30, fontsize=12)
axn[1][i].set_xticklabels(chunks, rotation=30, fontsize=12)
axn[0][i].set_yticks(ticks_delta)
axn[1][i].set_yticks(ticks_delta)
axn[0][i].set_yticklabels([str(d) for d in deltas])
axn[1][i].set_yticklabels(deltas)
fs = 13
axn[0][i].set_xlabel('chunk size', fontsize=fs)
axn[1][i].set_xlabel('chunk size', fontsize=fs)
fig.axes[-1].yaxis.label.set_size(15)
fig.axes[-2].yaxis.label.set_size(15)
for i in range(0, len(input_files)):
axn[0][i].set_title(titles[i], fontsize=13, pad=17)
fig.tight_layout(rect=[0, 0, len(input_files) * file_mul + .1, 1.3])
for ax in axn[0]:
ax.set_yticklabels([str(d) for d in deltas])
axn[0][0].set_ylabel('delta', fontsize=fs)
axn[1][0].set_ylabel('delta', fontsize=fs)
plt.show()
fig.savefig(result_image_name + ".png", bbox_inches="tight", transparent=True)
ax.set_ylabel("Number of Pixels")
if nside == 64:
ax.set_ylim([8e-1, 2e3])
#else:
# ax.set_ylim([8e-1, 1.5e5])
ax.set_yscale("symlog")
xlms = ax.get_xlim()
ylms = ax.get_ylim()
# Legend options
mpl.rcParams['legend.loc'] = 'best'
dummyHandle = Rectangle((0, 0),
1,
1,
fc="w",
fill=False,
edgecolor='none',
linewidth=0)
if args.plotFit:
lg = ax.legend([A[2][0], expPlot, fitPlot, dummyHandle], [
"Data", "Expectation", "Fit",
"mean = %.3f $\pm$ %.3f \nwidth = %.3f $\pm$ %.3f" %
(mean, meanerr, sigma, sigmaerr)
])
fitParam = lg.get_texts()[3]
fitParam.set_color('green')
fitParam._fontproperties = lg.get_texts()[0]._fontproperties.copy()
fitParam.set_size('medium')
else:
from matplotlib.backends.backend_agg import FigureCanvasAgg
figsize = 4.25, 5 * 0.55
xlim = 0.0, 11.0
ylim = 0.5, 5.0
dx = figsize[0] / (xlim[1] - xlim[0])
dy = figsize[1] / (ylim[1] - ylim[0])
widths = 1, 2, 3, 4, 5, 6
w, h = 0.75 * 10 / len(widths), 0.5
figsize = w * dx, h * dy
dpi = 600
for width in widths:
plt.rcParams["hatch.linewidth"] = width
fig = plt.figure(figsize=figsize, dpi=dpi)
ax = fig.add_axes([0, 0, 1, 1], xlim=[0, 1], ylim=[0, 1])
ax.axis("off")
canvas = FigureCanvasAgg(fig)
rect = Rectangle((0, 0),
1,
1,
hatch="/",
facecolor="0.85",
edgecolor="0.00",
linewidth=0.0)
ax.add_patch(rect)
canvas.draw()
image = np.frombuffer(canvas.tostring_rgb(), dtype="uint8")
image = image.reshape(int(figsize[1] * dpi), int(figsize[0] * dpi), 3)
imageio.imwrite("hatch-%d.png" % width, image)
def draw_court(ax=None, color="blue", lw=1, outer_lines=False):
if ax is None:
ax = plt.gca()
#Basketball Hoop
hoop = Circle((0, 0),
radius=7.5,
linewidth=lw,
color=color,
fill=False)
#backboard
backboard = Rectangle((-30, -12.5), 60, 0, linewidth=lw, color=color)
#the paiint
#outer box
outer_box = Rectangle((-80, -47.5),
160,
190,
linewidth=lw,
color=color,
fill=False)
#inner box
inner_box = Rectangle((-60, -47.5),
120,
190,
linewidth=lw,
color=color,
fill=False)
#freethrow top arc
top_free_throw = Arc((0, 142.5),
120,
120,
theta1=0,
theta2=180,
linewidth=lw,
color=color,
fill=False)
#freethrow bottom arc
bottom_free_throw = Arc((0, 142.5),
120,
120,
theta1=180,
theta2=0,
linewidth=lw,
color=color)
#restricted zone
restricted = Arc((0, 0),
80,
80,
theta1=0,
theta2=180,
linewidth=lw,
color=color)
#three point line
corner_three_a = Rectangle((-220, -47.5),
0,
140,
linewidth=lw,
color=color)
corner_three_b = Rectangle((220, -47.5),
0,
140,
linewidth=lw,
color=color)
three_arc = Arc((0, 0),
475,
475,
theta1=22,
theta2=158,
linewidth=lw,
color=color)
#center court
center_outer_arc = Arc((0, 422.5),
120,
120,
theta1=180,
theta2=0,
linewidth=lw,
color=color)
center_inner_arc = Arc((0, 422.5),
40,
40,
theta1=180,
theta2=0,
linewidth=lw,
color=color)
court_elements = [
hoop, backboard, outer_box, inner_box, top_free_throw,
bottom_free_throw, restricted, corner_three_a, corner_three_b,
three_arc, center_outer_arc, center_inner_arc
]
outer_lines = True
if outer_lines:
outer_lines = Rectangle((-250, -47.5),
500,
470,
linewidth=lw,
color=color,
fill=False)
court_elements.append(outer_lines)
for element in court_elements:
ax.add_patch(element)
fig = plt.figure()
ax = fig.add_subplot(111)
plt_x = []
plt_y = []
for p in points_plants:
plt_x.append(p["x"])
plt_y.append(p["y"])
# draw rect around radius
r = int(p["radius"])
ax.add_patch(
Rectangle(
xy=(p["x"] - r, p["y"] - r),
width=r * 2,
height=r * 2,
linewidth=2,
color="g",
fill=False,
))
ax.scatter(plt_x, plt_y, color=next(cycol), s=10)
# Add rectangles using resulting points as center
for p in points:
ax.add_patch(
# xy (bottom-left) uses coverage/2 area and offset for each axis to calc
Rectangle(
xy=(
p["x"] - (cover["x"] / 2) + offset["x"],
p["y"] - (cover["y"] / 2) + offset["y"],
),
width=cover["x"],
def create_artists(self, legend, orig_handle, xdescent, ydescent, width,
height, fontsize, trans):
p = Rectangle(xy=(-xdescent, -ydescent), width=width, height=height)
self.update_prop(p, orig_handle, legend)
p.set_transform(trans)
return [p]
def AddListenPatch(self, start_t, end_t, center_frequency_hz,
bandwidth_hz):
self.update_range(center_frequency_hz, bandwidth_hz)
p = Rectangle((start_t, center_frequency_hz - (bandwidth_hz / 2)),
end_t - start_t, bandwidth_hz)
self.rx_patches.append(p)
def addItem(self, x, y, legend, shape, color, fill, overlay, z):
xView = numpy.array(x, copy=False)
yView = numpy.array(y, copy=False)
if shape == "line":
item = self.ax.plot(x,
y,
label=legend,
color=color,
linestyle='-',
marker=None)[0]
elif shape == "hline":
if hasattr(y, "__len__"):
y = y[-1]
item = self.ax.axhline(y, label=legend, color=color)
elif shape == "vline":
if hasattr(x, "__len__"):
x = x[-1]
item = self.ax.axvline(x, label=legend, color=color)
elif shape == 'rectangle':
xMin = numpy.nanmin(xView)
xMax = numpy.nanmax(xView)
yMin = numpy.nanmin(yView)
yMax = numpy.nanmax(yView)
w = xMax - xMin
h = yMax - yMin
item = Rectangle(xy=(xMin, yMin),
width=w,
height=h,
fill=False,
color=color)
if fill:
item.set_hatch('.')
self.ax.add_patch(item)
elif shape in ('polygon', 'polylines'):
points = numpy.array((xView, yView)).T
if shape == 'polygon':
closed = True
else: # shape == 'polylines'
closed = numpy.all(numpy.equal(points[0], points[-1]))
item = Polygon(points,
closed=closed,
fill=False,
label=legend,
color=color)
if fill and shape == 'polygon':
item.set_hatch('/')
self.ax.add_patch(item)
else:
raise NotImplementedError("Unsupported item shape %s" % shape)
item.set_zorder(z)
if overlay:
item.set_animated(True)
self._overlays.add(item)
return item
def AddRxCorrectCircle(self, start_t, end_t, center_frequency_hz,
bandwidth_hz):
self.update_range(center_frequency_hz, bandwidth_hz)
p = Rectangle((start_t, center_frequency_hz - (bandwidth_hz / 2)),
end_t - start_t, bandwidth_hz)
self.tx_correct_patches.append(p)
def plot(figwidth, figheight, refseqtrack, LeftToRight, strand, depths, colors,
shade, limits, bedtrack, start, stop, staggerbed, bigwignames,
wig_df_list, shade_by_bed, output_folder, geneid, outputsuffix,
outputformat, dpi, track_names, axis_off, legend, staticaxes, bedfile,
bedtype, name, chrom, refseqid, annotate_bed, fontsize):
###### RUN TO PLOT! ######
print "Figure will be saved as: %s%s%s.%s" % (output_folder, geneid,
outputsuffix, outputformat)
# DON'T MODIFY
# Note: Need to clean up
tracks_to_use = range(len(track_names))
wigtracks_to_use = range(len(bigwignames))
seqtracks = len(tracks_to_use)
bedtracks = int(bedtrack)
wigtracks = len(wigtracks_to_use)
num_of_tracks = len(tracks_to_use) + int(bedtrack) + len(
wigtracks_to_use) + refseqtrack
height_ratios = ([3] * seqtracks + ([0.4] * bedtracks) + [1] * wigtracks +
[1] * refseqtrack)
if figwidth == 0:
figwidth = (stop - start) / 110
if limits == 'default':
limits = [start, stop]
myfont = {'size': fontsize}
rc('font', **myfont)
# Initialize Figure
fig, ax = plt.subplots(1)
fig.set_figwidth(figwidth)
fig.set_figheight(figheight)
gs = gridspec.GridSpec(seqtracks + bedtracks + wigtracks + refseqtrack,
1,
height_ratios=height_ratios)
plotnumber = iter(range(len(height_ratios)))
# check invert
invert = False
if LeftToRight and strand == "-":
invert = True
cur_axes = plt.gca()
ymax = max(depths.max())
# Build RNAseq Tracks
cur_axes_rna = []
for n in tracks_to_use:
color = colors.next()
plt.subplot(gs[plotnumber.next()])
plt.plot(depths.loc[:, track_names[n]], color=color, linewidth=1)
plt.fill_between(depths.index,
depths.loc[:, track_names[n]].tolist(),
color=shade.next(),
edgecolor='none')
plt.xlim(limits)
cur_axes_rna.append(plt.gca())
cur_axes_rna[n].axes.get_xaxis().set_visible(False)
cur_axes_rna[n].axes.get_yaxis().set_ticks(cur_axes_rna[n].get_ylim())
if axis_off:
cur_axes_rna[n].axes.axis("off")
if invert:
cur_axes_rna[n].invert_xaxis()
plt.tick_params(labelsize=fontsize)
if legend:
red_patch = mpatches.Patch(color=color, label=track_names[n])
plt.legend(handles=[red_patch], fontsize=fontsize)
if not staticaxes:
plt.ylim([0, ymax])
# Build Bedtracks
if bedtrack:
plt.subplot(gs[plotnumber.next()])
bedregions, bedlabels = graph_bed(bedfile,
bedtype,
name,
chrom,
start,
stop,
strand,
stagger=staggerbed)
cur_axes = plt.gca()
cur_axes.axes.get_xaxis().set_visible(False)
cur_axes.axes.get_yaxis().set_ticks([])
if axis_off:
cur_axes.axes.axis("off")
if invert:
cur_axes.invert_xaxis()
plt.ylabel(name,
rotation=0,
horizontalalignment="right",
verticalalignment="center")
plt.xlim(limits)
if staggerbed:
plt.ylim([-1, 2])
# Build Bigwig Tracks
if len(wigtracks_to_use) > 0:
for n in wigtracks_to_use:
plt.subplot(gs[plotnumber.next()])
color = colors.next()
wigdepths = graph_wig(wig_df_list[bigwignames[n]], name, chrom,
start, stop)
cur_axes = plt.gca()
cur_axes.axes.get_xaxis().set_visible(False)
cur_axes.axes.get_yaxis().set_ticks([])
if axis_off:
cur_axes.axes.axis("off")
if invert:
cur_axes.invert_xaxis()
plt.fill_between(wigdepths.index,
wigdepths["expression"].tolist(),
color=color)
plt.ylabel(bigwignames[n],
rotation=0,
horizontalalignment="right",
verticalalignment="center")
# To get relative ylim.. has weird values.
wig_ylim = [
wig_df_list[bigwignames[n]]["expression"].min(),
wig_df_list[bigwignames[n]]["expression"].max()
]
# Try again with just -3:3
wig_ylim = [-3, 3]
plt.ylim(wig_ylim)
plt.xlim(limits)
# Build Refseq Track
if refseqtrack:
plt.subplot(gs[plotnumber.next()])
graphRefseq(refseqid,
xlim=limits,
strand=strand,
LeftToRight=LeftToRight)
plt.ylabel(chrom,
rotation=0,
horizontalalignment="right",
verticalalignment="center")
cur_axes = plt.gca()
if shade_by_bed:
for b in bedregions:
for n in tracks_to_use:
# Rectangle(<start(xy)>,<width>,<height>)
cur_axes_rna[n].add_patch(
Rectangle((b[0] - 10, 0),
20,
ymax,
facecolor="#e2e2e2",
edgecolor='none',
alpha=0.7))
#cur_axes.axes.get_yaxis().set_visible(False)
cur_axes.axes.get_yaxis().set_ticks([])
plt.xlabel(geneid)
plt.ylabel(chrom)
if axis_off:
cur_axes.axes.spines['top'].set_visible(False)
cur_axes.axes.spines['right'].set_visible(False)
cur_axes.axes.spines['bottom'].set_visible(False)
cur_axes.axes.spines['left'].set_visible(False)
plt.xticks(visible=False)
if invert:
cur_axes.invert_xaxis()
if bedtrack:
# Remove duplicate bed entries
bedannotations = zip(bedlabels, bedregions)
bedannotations.sort()
bedannotations = list(i for i, _ in itertools.groupby(bedannotations))
print "======\nRegions\n======"
for label, x in bedannotations:
print label, x
if annotate_bed:
plt.annotate(label,
xy=(np.mean(x), 0),
xytext=(0, -45),
textcoords='offset points',
ha='right',
va='top',
rotation=45,
bbox=dict(boxstyle='round,pad=0.5',
fc='yellow',
alpha=0.5),
arrowprops=dict(arrowstyle='-',
connectionstyle='arc3,rad=0'))
#plt.gca().invert_xaxis()
#plt.tight_layout(pad=0.4, w_pad=0.5, h_pad=0.2)
plt.savefig("%s%s%s.%s" %
(output_folder, geneid, outputsuffix, outputformat),
format=outputformat,
bbox_inches='tight',
dpi=dpi)
return plt
linestyle=linestyle,
label=label,
linewidth=3)
print(key, perc_10, perc_50, perc_90)
superluminal_mu, superluminal_std = 0.30, 0.02
superluminal_mu = 180 - superluminal_mu * 360.0 / (2 * np.pi)
superluminal_std = superluminal_std * 360.0 / (2 * np.pi)
plt.plot([superluminal_mu, superluminal_mu], [0, 1],
alpha=0.3,
color='g',
label='Superluminal')
rect1 = Rectangle((superluminal_mu - superluminal_std, 0),
2 * superluminal_std,
0.05,
alpha=0.8,
color='g')
rect2 = Rectangle((superluminal_mu - 2 * superluminal_std, 0),
4 * superluminal_std,
0.05,
alpha=0.5,
color='g')
gws_mu, gws_std = 152, 14
plt.plot([gws_mu, gws_mu], [0, 1], alpha=0.3, color='r', label='GW')
rect3 = Rectangle((gws_mu - gws_std, 0),
2 * gws_std,
0.05,
alpha=0.3,
color='r')
def plot_block(block, utc_offset=0):
"""Visualize time usage of one observation block.
Parameters
-------
block : obsplanner.scheduler.ObsBlock
Observing block that should be visualized.
utc_offset : int, default=0
UTC offset for the time zone the telescope is located in. Used to show
the local time on the x-axis.
Returns
-------
fig : matplotlib.figure.Figure
The created figure.
"""
linewidth = 1
linestyle = '-'
edgecolor = 'k'
y = 1.2
gridspec_kw = {'width_ratios': (5, 1), 'wspace': 0.2}
fig, ax = plt.subplots(1, 2, figsize=(16, 9), gridspec_kw=gridspec_kw)
# plot block:
x = block.time_start.to_value('mjd')
width = block.duration.to_value('d')
rect = Rectangle((x, 0),
width,
y,
fill=False,
linewidth=linewidth,
linestyle=linestyle,
edgecolor=edgecolor)
ax[0].add_patch(rect)
# plot slew times:
for i, slew in enumerate(block.get_slew_periods()):
ax_add_slew(slew, ax[0])
# plot observations:
for i, obs in enumerate(block.get_observations()):
ax_add_obs(obs, ax[0])
# edit time axis:
xmin = block.time_start.to_value('mjd') - 1. / 24
xmax = block.time_stop.to_value('mjd') + 1. / 24
ax[0].set_xlim(xmin, xmax)
ax[0].xaxis.set_major_locator(MultipleLocator(1. / 12))
#ax[0].tick_params(
# axis='y', which='both', left=False, right=False,
# labelleft=False)
ax[0].set_yticks([0.15, 0.65, 1.1])
ax[0].set_yticklabels(['Slew periods', 'Obs. periods', 'Obs. block'])
ax[0].set_ylim(0, 1.5)
locs = ax[0].get_xticks()
time_utc = np.round(np.mod(locs, 1) * 24., 0)
time_loc = time_utc + utc_offset
labels = ['{0:.0f}\n{1:.0f}'.format(utc, loc) \
for (utc, loc) in zip(time_utc, time_loc)]
ax[0].set_xticklabels(labels)
ax[0].text(-0.06,
-0.03,
'UTC',
horizontalalignment='left',
transform=ax[0].transAxes)
ax[0].text(-0.06,
-0.05,
'UTC{0:+d}'.format(utc_offset),
horizontalalignment='left',
transform=ax[0].transAxes)
label = block.time_start.value[:10]
ax[0].set_xlabel(label)
# bar plots:
time_obs = block.time_obs.to_value('h')
time_slew = block.time_slew.to_value('h')
time_slew_idle = block.time_slew_idle.to_value('h')
time_idle = block.time_idle.to_value('h')
time_tot = block.duration.to_value('h')
ax[1].bar([1, 2, 3, 4], [time_obs, time_slew, time_slew_idle, time_idle],
color=['0.6', '0.7', '0.8', 'w'],
linestyle=linestyle,
linewidth=linewidth,
edgecolor='k')
offset = 0.01 * ax[1].get_ylim()[1]
ratio_obs = time_obs / time_tot
ratio_slew = time_slew / time_tot
ratio_slew_idle = time_slew_idle / time_tot
ratio_idle = time_idle / time_tot
ax[1].text(1,
time_obs + offset,
'{0:0.1f} %'.format(ratio_obs * 100.),
horizontalalignment='center')
ax[1].text(2,
time_slew + offset,
'{0:0.1f} %'.format(ratio_slew * 100.),
horizontalalignment='center')
ax[1].text(3,
time_slew_idle + offset,
'{0:0.1f} %'.format(ratio_slew_idle * 100.),
horizontalalignment='center')
ax[1].text(4,
time_idle + offset,
'{0:0.1f} %'.format(ratio_idle * 100.),
horizontalalignment='center')
ax[1].set_ylabel('hours')
labels = ['obs', 'slew\ntotal', 'slew\nidle', 'idle']
ax[1].set_xticks([1, 2, 3, 4])
ax[1].set_xticklabels(labels)
plt.setp(ax[1].xaxis.get_majorticklabels(), rotation=45)
return fig
pix_pad)).astype(int)
hmi_index_y_new = np.around(hmi_index_y + (thisxyshift[1].value -
pix_pad)).astype(int)
hmi_data = magnetic_flux_density_hmi_rot[
hmi_index_y_new[0]:hmi_index_y_new[1],
hmi_index_x_new[0]:hmi_index_x_new[1]]
# Now use the FFT image shift routine for better precision and
# create the final HMI cutout.
xshift, yshift = get_image_shift(hmi_data, tmp_hinode_data)
hmi_index_x_new += xshift
hmi_index_y_new += yshift
rect = Rectangle((hmi_xcoords[hmi_index_x_new[0]],hmi_ycoords[hmi_index_y_new[0]]), \
hmi_xcoords[hmi_index_x_new[1]]-hmi_xcoords[hmi_index_x_new[0]], \
hmi_ycoords[hmi_index_y_new[1]]-hmi_ycoords[hmi_index_y_new[0]], \
linewidth=1, edgecolor='r', facecolor='none')
ax.add_patch(rect)
# Plot the Hinode timestamp next to the rectangle
#ax.text(hmi_index_x_new[0], hmi_index_y_new[1]+15, HOP_336_info[jj][3], fontsize=10, color='red')
# Wasn't really legible, so put it at the top next to the title instead
plt.gcf().text(0.68,
0.983,
'Hinode: ' + HOP_336_info[jj][3],
fontsize=12)
fig.savefig(plot_directory + '{:06d}'.format(ii) + '.jpg',
dpi=107,
format='jpg',
quality=95)
def visualize(self,
file_name=None,
fig_size: (float, float) = (6.5, 6.5),
size_auv_path: float = 0.8,
size_max_radius: float = 0.3,
size_min_radius: float = 0.1,
tick_size: float = 14,
grid_width: float = 0.25,
size_arrow_h_width: float = 0.4,
size_arrow_h_length: float = 0.3,
size_arrow_width: float = 0.4,
color_obstacle: str = 'firebrick',
color_target: str = 'deepskyblue',
color_auv: str = 'darkorange',
color_auv_path: str = 'peachpuff',
visited_reward_opacity: float = 0.15) -> Figure:
if (fig_size[0] <= 0 or fig_size[1] <= 0 or size_auv_path <= 0
or size_max_radius <= 0 or size_arrow_h_width <= 0
or size_arrow_h_length <= 0 or size_arrow_width <= 0
or tick_size <= 0 or grid_width <= 0):
raise ValueError("Size must be positive")
max_reward = self._environment.max_reward
title_font = {
'fontname': 'Sans Serif',
'size': '16',
'color': 'black',
'weight': 'bold'
}
z = {'auv_path': 1, 'target': 2, 'obstacle': 3, 'auv': 5}
# Initialize the figure
fig = plt.figure(figsize=fig_size)
ax = fig.add_subplot(111)
plt.hlines(y=range(self._environment.y_min,
self._environment.y_max + 1),
xmin=self._environment.x_min,
xmax=self._environment.x_max,
color='k',
linewidth=grid_width,
zorder=0)
plt.vlines(x=range(self._environment.x_min,
self._environment.x_max + 1),
ymin=self._environment.y_min,
ymax=self._environment.y_max,
color='k',
linewidth=grid_width,
zorder=0)
# Plot obstacles
for i, j in self._environment.obstacles:
ax.add_patch(
Rectangle(xy=(i, j),
width=1,
height=1,
color=color_obstacle,
zorder=z['obstacle']))
# Plot rewards
for position, reward in self._environment.rewards.items():
target_radius = ((reward / max_reward) *
(size_max_radius - size_min_radius) +
size_min_radius)
centroid = (position[0] + 0.5, position[1] + 0.5)
ax.add_patch(
Circle(xy=centroid,
radius=target_radius,
color=color_target,
zorder=z['target'],
alpha=(visited_reward_opacity
if position in self.visited else 1.0)))
# Plot agents
for path in self._paths:
x, y = path[-1]
dx, dy = 0, 1
if len(path) >= 2:
x_p, y_p = path[-2]
if x == x_p + 1 and y == y_p:
dx, dy = 1, 0
elif x == x_p - 1 and y == y_p:
dx, dy = -1, 0
elif x == x_p and y == y_p - 1:
dx, dy = 0, -1
x += 0.5 * float(1 - dx)
y += 0.5 * float(1 - dy)
ax.add_patch(
FancyArrow(x=x,
y=y,
dx=dx,
dy=dy,
fc=color_auv,
width=size_arrow_width,
head_width=size_arrow_h_width,
head_length=size_arrow_h_length,
zorder=z['auv'],
length_includes_head=True))
# plot trajectories
for i in range(1, len(path)):
x, y = path[i]
x_p, y_p = path[i - 1]
ax.add_line(
Line2D(xdata=(x + 0.5, x_p + 0.5),
ydata=(y + 0.5, y_p + 0.5),
linewidth=size_auv_path * 10,
color=color_auv_path,
zorder=z['auv_path']))
# Plotting
plt.title('AUV Trajectory \n Accumulated Reward: ' + str(self.reward),
title_font)
plt.xlabel('x', title_font)
plt.ylabel('y', title_font)
x_ticks = np.arange(self._environment.x_min,
self._environment.x_max + 1, 1)
y_ticks = np.arange(self._environment.y_min,
self._environment.y_max + 1, 1)
plt.xticks(x_ticks + 0.5, x_ticks.astype(int))
plt.yticks(y_ticks + 0.5, y_ticks.astype(int))
ax.tick_params(labelsize=tick_size)
ax.grid(False)
ax.axis('equal')
ax.set_xlim(self._environment.x_min - 0.5,
self._environment.x_max + 1.5)
ax.set_ylim(self._environment.y_min - 0.5,
self._environment.y_max + 1.5)
# Save and display
plt.show()
if file_name is not None:
plt.savefig(file_name)
return fig
def rectangles(x,
y,
sw,
sh=None,
c='b',
ax=None,
vmin=None,
vmax=None,
**kwargs):
"""
Make a scatter of squares plot of x vs y, where x and y are sequence
like objects of the same lengths. The size of sqares are in data scale.
Parameters
----------
x,y : scalar or array_like, shape (n, )
Input data
s : scalar or array_like, shape (n, )
side of square in data scale (ie. in data unit)
c : color or sequence of color, optional, default : 'b'
`c` can be a single color format string, or a sequence of color
specifications of length `N`, or a sequence of `N` numbers to be
mapped to colors using the `cmap` and `norm` specified via kwargs.
Note that `c` should not be a single numeric RGB or
RGBA sequence because that is indistinguishable from an array of
values to be colormapped. `c` can be a 2-D array in which the
rows are RGB or RGBA, however.
ax : Axes object, optional, default: None
Parent axes of the plot. It uses gca() if not specified.
vmin, vmax : scalar, optional, default: None
`vmin` and `vmax` are used in conjunction with `norm` to normalize
luminance data. If either are `None`, the min and max of the
color array is used. (Note if you pass a `norm` instance, your
settings for `vmin` and `vmax` will be ignored.)
Returns
-------
paths : `~matplotlib.collections.PathCollection`
Other parameters
----------------
kwargs : `~matplotlib.collections.Collection` properties
eg. alpha, edgecolors, facecolors, linewidths, linestyles, norm, cmap
Examples
--------
a = np.arange(11)
squaress(a, a, a*0.2, c=a, alpha=0.5, edgecolor='none')
License
--------
This code is under [The BSD 3-Clause License]
(http://opensource.org/licenses/BSD-3-Clause)
"""
#import matplotlib.colors as colors
if ax is None:
ax = mpl.gca()
if isinstance(c, basestring):
color = c # ie. use colors.colorConverter.to_rgba_array(c)
else:
color = None # use cmap, norm after collection is created
kwargs.update(color=color)
if sh is None:
sh = sw
x = x - sw / 2. # offset as position specified is "lower left corner"
y = y - sh / 2.
if np.isscalar(x):
patches = [
Rectangle((x, y), sw, sh),
]
elif np.isscalar(sw):
patches = [Rectangle((x_, y_), sw, sh) for x_, y_ in zip(x, y)]
else:
patches = [
Rectangle((x_, y_), sw_, sh_)
for x_, y_, sw_, sh_ in zip(x, y, sw, sh)
]
collection = PatchCollection(patches, **kwargs)
if color is None:
collection.set_array(np.asarray(c))
if vmin is not None or vmax is not None:
collection.set_clim(vmin, vmax)
ax.add_collection(collection)
ax.autoscale_view()
return collection
def coordinates(filelist, **kwargs):
""" Find all coordinates in a list of image files.
Usage: fig = sims.coordinates([a.im, b.im], labels=['A', 'B'])
For each image in the list, the stage coordinates and raster size are extracted.
A box scaled to the rastersize is plotted for each image on a (X,Y) grid.
A label for each file can be given. If it's omitted, the filename will be printed
over the box, but no attempt is made to make the filename fit in the box.
Returns a matplotlib figure instance.
"""
labels = kwargs.pop('labels', filelist)
patches = []
x_min = None
fig = mpl.figure()
ax = fig.gca()
for fn, lb in zip(filelist, labels):
s = sims.SIMSOpener(fn)
s.peek()
s.read_header()
s.close()
# Remember!! In Cameca-land, X is up-down, Y is left-right. Fix here.
x = s.header['sample y']
y = s.header['sample x']
if (x == 0 and y == 0):
warnings.warn('Coordinates for file {} are 0,0.'.format(fn))
if (('PrimaryBeam' in s.header.keys())
and ('raster' in s.header['PrimaryBeam'].keys())):
raster = s.header['PrimaryBeam']['raster']
elif (('Image' in s.header.keys())
and ('raster' in s.header['Image'].keys())):
raster = s.header['Image']['raster'] / 1000
else:
warnings.warn('No raster size in header of file {}.'.format(fn))
raster = 0
# Text uses center of image coordinate, box uses lower left.
ax.text(x, y, lb, ha='center', va='center', fontsize=8)
x -= raster / 2
y -= raster / 2
# Update data limits, relim() used by autoview does not work with collections (yet)
if not x_min:
# first pass
x_min = x
x_max = x + raster
y_min = y
y_max = y + raster
else:
if x < x_min: x_min = x
if x + raster > x_max: x_max = x + raster
if y < y_min: y_min = y
if y + raster > y_max: y_max = y + raster
rect = Rectangle((x, y),
raster,
raster,
ec='black',
fc='white',
fill=False)
patches.append(rect)
collection = PatchCollection(patches, match_original=True)
ax.add_collection(collection)
# Set view limits
x_span = x_max - x_min
y_span = y_max - y_min
# Remember!! In Cameca-land, X-axis (up-down) is positive downwards,
# Y-axis (left-right) is positive going right.
ax.set_xlim(x_min - 0.1 * x_span, x_max + 0.1 * x_span)
ax.set_ylim(y_max + 0.1 * y_span, y_min - 0.1 * y_span)
# Keep it square
ax.set_aspect('equal', adjustable='datalim')
ax.set_xlabel('Stage Y (μm)')
ax.set_ylabel('Stage X (μm)')
return fig
def sample_in_windows(drive_contour: np.ndarray, driven_contour: np.ndarray,
window_pairs: List[Tuple[Window_T, Window_T]], keep_count: int,
debugging_suite: ReportingSuite, k: int = 1, center_determine_function=center_of_window,
sampling_accuracy=1024, torque_weight=0.0, mismatch_penalty: float = 0.5) \
-> List[Tuple[float, Window_T, Window_T, Polar_T, float, float]]:
"""
find the best sample windows
:param drive_contour: the drive contour
:param driven_contour: the driven contour
:param window_pairs: pair of windows
:param keep_count: count of the windows to be kept
:param debugging_suite: the debugging suite
:param k: the k of the opposing gear
:param center_determine_function: function to determine from window to center
:param sampling_accuracy: number of samples when converting to polar contour
:param torque_weight: weight of torque term
:param mismatch_penalty: penalty for the extended d_driven not matching start and end (only for k>1)
:return: list of (score, drive_window, driven_window, reconstructed_drive, max_phi, mismatch_penalty)
"""
results = []
path_prefix = debugging_suite.path_prefix # store in a directory
if debugging_suite.figure is not None:
debugging_suite.figure.clear() # clear the figure
plt.figure(debugging_suite.figure.number)
subplots = debugging_suite.figure.subplots(2, 2)
update_polygon_subplots(drive_contour, driven_contour, subplots[0])
else:
subplots = None
for index, (drive_window, driven_window) in enumerate(window_pairs):
center_drive = center_determine_function(drive_window)
center_driven = center_determine_function(driven_window)
if not (Polygon(drive_contour).contains(Point(*center_drive)) and Polygon(driven_contour).contains(
Point(*center_driven))):
# not good windows
continue
# polar, dist, phi = compute_dual_gear(
# toExteriorPolarCoord(Point(*center_driven), driven_contour, sampling_accuracy), 1)
# polar, dist, phi = compute_dual_gear(polar, 1)
# d_phi = differentiate_function(pre_process(phi))
# fig, splts = plt.subplots(2, 2, figsize=(9, 9))
# splts[0][1].plot(*driven_contour.transpose())
# splts[0][1].axis('equal')
# splts[1][0].plot(np.linspace(0, 2 * math.pi, len(phi), endpoint=False), phi)
# splts[1][1].plot(np.linspace(0, 2 * math.pi, len(d_phi), endpoint=False), d_phi, color='red')
# plt.show() #checkpoint passed
distance, d_drive, d_driven, dist_drive, dist_driven = \
contour_distance(drive_contour, center_drive, driven_contour, center_driven, sampling_accuracy, k)
# splts[1][1].plot(np.linspace(0, 2 * math.pi, len(d_driven), endpoint=False), d_driven, color='blue')
# plt.show()
reconstructed_drive = rebuild_polar(0.9, align_and_average(d_drive, d_driven, k=k))
list_reconstructed_drive = list(reconstructed_drive)
max_phi = max(differentiate_function(pre_process(compute_dual_gear(list_reconstructed_drive)[-1])))
final_score = distance + torque_weight * max_phi
m_penalty = None
if k != 1:
m_penalty = mismatch_penalty * abs(d_driven[0] - d_driven[-1])
logger.info(f'{index} gear: mismatching start = {d_driven[0]}, end = {d_driven[-1]}, penalized {m_penalty}')
final_score += m_penalty
logging.info(f'{index} gear: plain score={distance}, max of phi\'={max_phi}')
results.append((final_score, drive_window, driven_window, list_reconstructed_drive, max_phi, m_penalty))
if subplots is not None:
update_polygon_subplots(drive_contour, driven_contour, subplots[0]) # clear sample regions
reconstructed_driven, plt_center_dist, plt_phi = compute_dual_gear(list_reconstructed_drive, k)
reconstructed_drive_contour = toCartesianCoordAsNp(reconstructed_drive, 0, 0)
reconstructed_driven_contour = toCartesianCoordAsNp(reconstructed_driven, 0, 0)
update_polygon_subplots(reconstructed_drive_contour, reconstructed_driven_contour, subplots[1])
min_x, max_x, min_y, max_y = drive_window
sample_region = Rectangle((min_x, min_y), max_x - min_x, max_y - min_y, color='red', fill=False)
subplots[0][0].add_patch(sample_region)
min_x, max_x, min_y, max_y = driven_window
sample_region = Rectangle((min_x, min_y), max_x - min_x, max_y - min_y, color='red', fill=False)
subplots[0][1].add_patch(sample_region)
subplots[0][0].scatter(*center_drive, 5)
subplots[0][1].scatter(*center_driven, 5)
subplots[1][0].scatter(0, 0, 5)
subplots[1][1].scatter(0, 0, 5)
plt.savefig(path_prefix + f'{index}.png')
save_contour(path_prefix + f'{index}_drive.dat', reconstructed_drive_contour)
save_contour(path_prefix + f'{index}_driven.dat', reconstructed_driven_contour)
save_information(path_prefix + f'{index}.txt', center_drive, center_driven, final_score,
max_dphi_drive=max_phi, actual_distance=distance, mismatch_penalty=m_penalty)
# get information about thee phi' functions
original_figure = plt.gcf()
figure, new_subplots = plt.subplots(2, 2, figsize=(16, 16))
new_subplots[0][0].plot(np.linspace(0, 2 * math.pi, len(d_drive), endpoint=False), d_drive)
new_subplots[0][0].axis([0, 2 * math.pi, 0, 2 * math.pi])
new_subplots[0][1].plot(np.linspace(0, 2 * math.pi, len(d_driven), endpoint=False), d_driven)
new_subplots[0][1].axis([0, 2 * math.pi, 0, 2 * math.pi])
new_subplots[1][0].plot(np.linspace(0, 2 * math.pi, len(d_drive), endpoint=False),
align_and_average(d_drive, d_driven, k=k))
new_subplots[1][0].axis([0, 2 * math.pi, 0, 2 * math.pi])
debugging_suite.plotter.draw_contours(
path_prefix + f'drive_contour_{index}.png',
[('carve_drive', drive_contour)],
[center_drive])
debugging_suite.plotter.draw_contours(
path_prefix + f'driven_contour_{index}.png',
[('carve_driven', driven_contour)],
[center_driven])
final_driven = np.array(
psf_rotate(toCartesianCoordAsNp(reconstructed_driven, plt_center_dist, 0), plt_phi[0],
(plt_center_dist, 0)))
debugging_suite.plotter.draw_contours(
path_prefix + f'reconstructed_contour_{index}.png',
[('carve_drive', reconstructed_drive_contour),
('carve_driven', final_driven)],
[(0, 0), (plt_center_dist, 0)])
if k != 1:
# then offset shall be 0
new_subplots[1][1].plot(np.linspace(0, 2 * math.pi, len(d_drive), endpoint=False),
extend_part(d_driven, 0, int(len(d_driven) / k), len(d_drive)))
new_subplots[1][1].axis('equal')
plt.axis('equal')
plt.savefig(path_prefix + f'{index}_functions.png')
plt.close()
plt.figure(original_figure.number)
results.sort(key=lambda dist, *_: dist)
return results[:keep_count]
