def init_figures(issplit, isvector, naxes, nplots): """ initialize figures and set up backends issplit: true if we're making separate vector and raster figures isvector: true if we're making vector lines naxes: number of axes, used for sizing nplots: number of subplots, used for sizing """ figsize = (3 + 0.6 * naxes, 2 + (4 / 3) * nplots) # figsize = (3 + 0.6 * naxes, 2 + (10/3) * nplots) if issplit: raster = matplotlib.figure.Figure(figsize=figsize) agg.FigureCanvasAgg(raster) vector = matplotlib.figure.Figure(figsize=figsize) svg.FigureCanvasSVG(vector) elif isvector: vector = matplotlib.figure.Figure(figsize=figsize) svg.FigureCanvasSVG(vector) raster = vector else: raster = matplotlib.figure.Figure(figsize=figsize) agg.FigureCanvasAgg(raster) vector = raster return raster, vector
def plot_heldout_prediction(input_vals, probs, fname, title=""): """Plotting uncertainity in prediction of a sampled image . Args: input_vals: A `float`-like Numpy `array` of shape IMAGE_SHAPE`, containing a sampled test image. probs: A `float`-like Numpy array of shape `[num_monte_carlo, 1, num_classes]` containing Monte Carlo samples of class probabilities for a test image. fname: Python `str` filename to save the plot to. title: Python `str` title for the plot. """ save_dir = os.path.join(DATA_DIR, "..", "Plots") fig = figure.Figure(figsize=(1, 1)) canvas = backend_agg.FigureCanvasAgg(fig) ax = fig.add_subplot(1, 1, 1) ax.imshow(input_vals.reshape((IMG_SIZE, IMG_SIZE)), interpolation="None") canvas.print_figure(os.path.join(save_dir, fname + "_image.png"), format="png") fig = figure.Figure(figsize=(10, 5)) canvas = backend_agg.FigureCanvasAgg(fig) ax = fig.add_subplot(1, 1, 1) #Predictions y_pred_list = list(np.argmax(probs, axis=1).astype(np.int32)) bin_range = [x for x in range(43)] ax.hist(y_pred_list, bins=bin_range) ax.set_xticks(bin_range) ax.set_title("Histogram of predicted class: " + title) ax.set_xlabel("Class") ax.set_ylabel("Frequency") fig.tight_layout() save_dir = os.path.join(DATA_DIR, "..", "Plots") canvas.print_figure(os.path.join(save_dir, fname + "_predicted_class.png"), format="png") print("saved {}".format(fname))
def grafic(tela): # soma_indices = 1 import matplotlib import matplotlib.pyplot as plt pygame.draw.rect(tela, cinza, (0, 0, 1200, 800), 0) matplotlib.use("Agg") import matplotlib.backends.backend_agg as agg processos_infos = [] for processos in psutil.process_iter(): processos_infos.append({ "pid": processos.pid, "nome": processos.name(), "rss": processos.memory_info().rss, "vms": processos.memory_info().vms }) names = [info["pid"] for info in processos_infos] values1 = [info["vms"] / 1024 / 1024 for info in processos_infos] values2 = [info["rss"] / 1024 / 1024 for info in processos_infos] fig_1, axs = plt.subplots() lines_1, = axs.plot(names, values1) plt.xlabel("pid") plt.ylabel("vms") plt.setp(lines_1, color='b', linewidth=1.0) fig_1.suptitle('PID X VMS') fig_2, axs = plt.subplots() lines_2, = axs.plot(names, values2) plt.xlabel("pid") plt.ylabel("rss") plt.setp(lines_2, color='b', linewidth=1.0) fig_2.suptitle('PID X RSS') canvas_1 = agg.FigureCanvasAgg(fig_1) canvas_1.draw() tamanho_1 = canvas_1.get_width_height() renderer = canvas_1.get_renderer() raw_data_1 = renderer.tostring_rgb() canvas_2 = agg.FigureCanvasAgg(fig_2) canvas_2.draw() tamanho_2 = canvas_2.get_width_height() renderer = canvas_2.get_renderer() raw_data_2 = renderer.tostring_rgb() superficie_grafico_1 = pygame.image.fromstring(raw_data_1, tamanho_1, "RGB") tela.blit(superficie_grafico_1, (0, 150)) superficie_grafico_2 = pygame.image.fromstring(raw_data_2, tamanho_2, "RGB") tela.blit(superficie_grafico_2, (590, 150))
def latex_to_png_mpl(s, wrap, color='Black', scale=1.0): try: from matplotlib import figure, font_manager, mathtext from matplotlib.backends import backend_agg from pyparsing import ParseFatalException except ImportError: return None # mpl mathtext doesn't support display math, force inline s = s.replace('$$', '$') if wrap: s = u'${0}$'.format(s) try: prop = font_manager.FontProperties(size=12) dpi = 120 * scale buffer = BytesIO() # Adapted from mathtext.math_to_image parser = mathtext.MathTextParser("path") width, height, depth, _, _ = parser.parse(s, dpi=72, prop=prop) fig = figure.Figure(figsize=(width / 72, height / 72)) fig.text(0, depth / height, s, fontproperties=prop, color=color) backend_agg.FigureCanvasAgg(fig) fig.savefig(buffer, dpi=dpi, format="png", transparent=True) return buffer.getvalue() except (ValueError, RuntimeError, ParseFatalException): return None
def create_graph(figure, plot_size): canvas = agg.FigureCanvasAgg(figure) canvas.draw() renderer = canvas.get_renderer() raw_data = renderer.tostring_rgb() graph = pygame.image.fromstring(raw_data, plot_size, "RGB") return graph
def grafica(): fig = pylab.figure( figsize=[4, 4], # Inches dpi=100, # 100 dots per inch, so the resulting buffer is 400x400 pixels ) ax = fig.gca() ax.plot([1, 2, 4]) canvas = agg.FigureCanvasAgg(fig) canvas.draw() renderer = canvas.get_renderer() raw_data = renderer.tostring_rgb() pygame.init() window = pygame.display.set_mode((600, 400), DOUBLEBUF) screen = pygame.display.get_surface() size = canvas.get_width_height() surf = pygame.image.fromstring(raw_data, size, "RGB") screen.blit(surf, (0, 0)) pygame.display.flip() crashed = False while not crashed: for event in pygame.event.get(): if event.type == pygame.QUIT: crashed = True
def plot_heldout_prediction(input_vals, probs, fname, n=10, title=""): """Save a PNG plot visualizing posterior uncertainty on heldout data. Args: input_vals: A `float`-like Numpy `array` of shape `[num_heldout] + IMAGE_SHAPE`, containing heldout input images. probs: A `float`-like Numpy array of shape `[num_monte_carlo, num_heldout, num_classes]` containing Monte Carlo samples of class probabilities for each heldout sample. fname: Python `str` filename to save the plot to. n: Python `int` number of datapoints to vizualize. title: Python `str` title for the plot. """ fig = figure.Figure(figsize=(9, 3 * n)) canvas = backend_agg.FigureCanvasAgg(fig) for i in range(n): ax = fig.add_subplot(n, 3, 3 * i + 1) ax.imshow(input_vals[i, :].reshape(IMAGE_SHAPE[:-1]), interpolation="None") ax = fig.add_subplot(n, 3, 3 * i + 2) for prob_sample in probs: sns.barplot(np.arange(10), prob_sample[i, :], alpha=0.1, ax=ax) ax.set_ylim([0, 1]) ax.set_title("posterior samples") ax = fig.add_subplot(n, 3, 3 * i + 3) sns.barplot(np.arange(10), np.mean(probs[:, i, :], axis=0), ax=ax) ax.set_ylim([0, 1]) ax.set_title("predictive probs") fig.suptitle(title) fig.tight_layout() canvas.print_figure(fname, format="png") print("saved {}".format(fname))
def figure_to_image(figure, close=True): """Render matplotlib figure to numpy format. Returns: numpy.array: image in [CHW] order """ if not np: logger.warning(NUMPY_ERROR_MESSAGE) try: import matplotlib.pyplot as plt import matplotlib.backends.backend_agg as plt_backend_agg except ImportError: logger.warning(MATPLOTLIB_ERROR_MESSAGE) canvas = plt_backend_agg.FigureCanvasAgg(figure) canvas.draw() data = np.frombuffer(canvas.buffer_rgba(), dtype=np.uint8) w, h = figure.canvas.get_width_height() image_hwc = data.reshape([h, w, 4])[:, :, 0:3] image_chw = np.moveaxis(image_hwc, source=2, destination=0) if close: try: plt.close(figure.number) except: plt.close(figure) return image_chw
def desenha_grafico(tipo): import matplotlib import matplotlib.pyplot as plt matplotlib.use("Agg") import matplotlib.backends.backend_agg as agg lista_p, lista_v = pega_processos(tipo) names = lista_p values = lista_v fig, axs = plt.subplots() axs.plot(names, values) posicao_grafico = 0 if (tipo == "grafico_vms"): fig.suptitle('Uso de memoria VMS') posicao_grafico = 70 else: fig.suptitle('Uso de memoria RSS') posicao_grafico = 550 canvas = agg.FigureCanvasAgg(fig) canvas.draw() size = canvas.get_width_height() renderer = canvas.get_renderer() raw_data = renderer.tostring_rgb() surf = pygame.image.fromstring(raw_data, size, "RGB") tela.blit(surf, (100, posicao_grafico))
def draw_loss_graph(train_loss_list, test_loss_list, train_epoch_list=None, test_epoch_list=None, train_color='blue', test_color='red', legend_loc='upper right', title=None): # Axis data # Losses train_loss = np.asarray(train_loss_list) test_loss = np.asarray(test_loss_list) # Epochs if train_epoch_list: train_epoch = np.asarray(train_epoch_list) else: train_epoch = np.arange(0, len(train_loss_list)) if test_epoch_list: test_epoch = np.asarray(test_epoch_list) else: test_epoch = np.arange(0, len(test_loss_list)) # Create new figure plt.clf() fig, ax = plt.subplots() ax.plot(train_epoch, train_loss, label='train', color=train_color) ax.plot(test_epoch, test_loss, label='test', color=test_color) def draw_annotate(label, x, y, color): ax.scatter(x, y, 20, color=color) ax.annotate(label, xy=(x, y), xytext=(+20, +10), textcoords='offset points', arrowprops={'arrowstyle': '->', 'connectionstyle': 'arc3,rad=.2'}) # Show min values if train_loss.shape[0] > 0: min_idx = np.argmin(train_loss) x, y = train_epoch[min_idx], train_loss[min_idx] draw_annotate('min train loss: %0.3f' % y, x, y, train_color) if test_loss.shape[0] > 0: min_idx = np.argmin(test_loss) x, y = test_epoch[min_idx], test_loss[min_idx] draw_annotate('min test loss: %0.3f' % y, x, y, test_color) # Settings ax.set_xlabel("epoch") ax.set_ylabel("loss rate") ax.set_xlim(left=0) ax.set_ylim(bottom=0) ax.legend(loc=legend_loc) if title is not None: ax.set_title(title) # Draw canvas = agg.FigureCanvasAgg(fig) canvas.draw() renderer = canvas.get_renderer() img = np.fromstring(renderer.tostring_rgb(), dtype=np.uint8, sep='') img = img.reshape(canvas.get_width_height()[::-1] + (3,)) # Close plt.close('all') return img
def make_pie(size, values, labels, title): """ make a pie chart using matplotlib. return the chart as a pygame surface make the pie chart a square that is as tall as the display. """ logging.debug('make_pie(...,...,%s)', title) inches = size[1] / 100.0 fig = plt.figure(figsize=(inches, inches), dpi=100, tight_layout={'pad': 0.10}, facecolor='k') ax = fig.add_subplot(111) ax.pie(values, labels=labels, autopct='%1.1f%%', textprops={'color': 'w'}, wedgeprops={'linewidth': 0.25}, colors=('b', 'g', 'r', 'c', 'm', 'y', '#ff9900', '#00ff00', '#663300')) ax.set_title(title, color='white', size=48, weight='bold') handles, labels = ax.get_legend_handles_labels() legend = ax.legend(handles[0:5], labels[0:5], title='Top %s' % title, loc='lower left') # best frame = legend.get_frame() frame.set_color((0, 0, 0, 0.75)) frame.set_edgecolor('w') legend.get_title().set_color('w') for text in legend.get_texts(): plt.setp(text, color='w') canvas = agg.FigureCanvasAgg(fig) canvas.draw() renderer = canvas.get_renderer() raw_data = renderer.tostring_rgb() plt.close(fig) canvas_size = canvas.get_width_height() logging.debug('make_pie(...,...,%s) done', title) return raw_data, canvas_size
def render(self, state): width = self.resolution[0] / self.dpi height = self.resolution[1] / self.dpi fig = plt.figure(0, figsize=(width, height), dpi=self.dpi) current, wait, backlog, time = state lines = current.shape[0] # Axes {{{ axs_current = [ plt.subplot2grid((lines, 3), (i, 0)) for i in range(lines) ] axs_wait = [plt.subplot2grid((lines, 3), (i, 1)) for i in range(lines)] ax_backlog = plt.subplot2grid((lines, 3), (0, 2), rowspan=lines) # End of Axes }}} for i, (ax_current, ax_wait) in enumerate(zip(axs_current, axs_wait)): self.plot_substate(ax_current, f'Current resources {i}', current[i]) self.plot_substate(ax_wait, f'Waiting jobs stack {i}', np.mean(wait[i], axis=0)) self.plot_substate(ax_backlog, 'Backlog', backlog, True) fig.tight_layout() canvas = agg.FigureCanvasAgg(fig) canvas.draw() renderer = canvas.get_renderer() raw_data = renderer.tostring_rgb() size = canvas.get_width_height() plt.close(fig) return np.frombuffer(raw_data, dtype=np.uint8).reshape( (size[0], size[1], 3))
def draw_hand(): ax.plot([1, 2, 4]) canvas = agg.FigureCanvasAgg(fig) canvas.draw() renderer = canvas.get_renderer() raw_data = renderer.tostring_rgb() pygame.init() window = pygame.display.set_mode((600, 400), DOUBLEBUF) screen = pygame.display.get_surface() size = canvas.get_width_height() surf = pygame.image.fromstring(raw_data, size, "RGB") screen.blit(surf, (0,0)) pygame.display.flip() while True: pass
def FigureToSummary(name, fig): """Create tf.Summary proto from matplotlib.figure.Figure. Args: name: Summary name. fig: A matplotlib figure object. Returns: A `tf.Summary` proto containing the figure rendered to an image. """ canvas = backend_agg.FigureCanvasAgg(fig) fig.canvas.draw() ncols, nrows = fig.canvas.get_width_height() png_file = six.BytesIO() canvas.print_figure(png_file) png_str = png_file.getvalue() return tf.Summary(value=[ tf.Summary.Value( tag='%s/image' % name, image=tf.Summary.Image( height=nrows, width=ncols, colorspace=3, encoded_image_string=png_str)) ])
def create_canvas_and_axes(self): # Create a figure. fig = figure.Figure() # Create a canvas and add the figure to it self.canvas = backend_agg.FigureCanvasAgg(fig) self.axes = fig.add_subplot(111)
def update_env(): obs = env.reset(wd=wd, ws=ws) print(f'initializing flow filed for {wd} with {env.cur_yaws}') farm.reinitialize_flow_field(wind_direction=[wd], wind_speed=[ws]) farm.calculate_wake(yaw_angles=env.cur_yaws) nominal_power = farm.get_farm_power() print(f'nominal power {nominal_power}') action = agent.compute_action(obs) print(f'actions : {action}') # Execute the actions if env.continuous_action_space: env.cur_yaws = action * env.allowed_yaw else: env.cur_yaws = action - env.allowed_yaw farm.calculate_wake(yaw_angles=env.cur_yaws) # obs, reward, done, info = env.step(action=action, no_variation=True) steering_power = farm.get_farm_power() hor_plane = farm.get_hor_plane( height=farm.floris.farm.turbines[0].hub_height ) # x_resolution=400, y_resolution=100) # Plot and show fig, ax = plt.subplots() wfct.visualization.visualize_cut_plane(hor_plane, ax=ax) canvas = agg.FigureCanvasAgg(fig) canvas.draw() renderer = canvas.get_renderer() size = canvas.get_width_height() raw_data = renderer.tostring_rgb() surf = pygame.image.fromstring(raw_data, size, "RGB") return surf, nominal_power, steering_power
def PlotBlockBar(BlockNumber, FigSize=3, xpos=.5, ypos=.5, UPDATE=False): matplotlib.rcParams.update({'font.size': 22}) X = np.linspace(0, BlockNumber, BlockNumber + 1) fig = pylab.figure(figsize=(FigSize * 6, FigSize), dpi=100) ax = fig.gca() ax.barh(np.asarray([0]), np.asarray([BlockNumber + 1]), align='center', color='green') plt.xticks(range(Blocks + 1)) ax.set_xlim(0, Blocks) labels = ['Prac'] alphabet = [ '0', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z' ] [labels.append(alphabet[i]) for i in range(1, Blocks)] labels.append('End!') ax.set_xticklabels([]) ax.set_ylim(-.005, .005) ax.get_yaxis().set_visible(False) ax.tick_params(axis='x', length=100, width=2) bg = str(BG[0] / 255.) fig.patch.set_facecolor(bg) canvas = agg.FigureCanvasAgg(fig) canvas.draw() renderer = canvas.get_renderer() raw_data = renderer.tostring_rgb() size = canvas.get_width_height() surf = pygame.image.fromstring(raw_data, size, "RGB") screen = DISPLAYSURF screen.blit( pygame.transform.scale(surf, (1200, 200)), (int(WINDOW_WIDTH * xpos + 150), int(WINDOW_HEIGHT * ypos - 150)))
def graph_results(score, length): fig = pylab.figure(figsize=[4, 4], dpi=90) ax = fig.gca() ax.plot(score) ax.set_title("Agents score over {}/{} Iteration".format( length, len(score))) ax.set_xlabel('Iteration') ax.set_ylabel('Score') canvas = agg.FigureCanvasAgg(fig) canvas.draw() renderer = canvas.get_renderer() raw_data = renderer.tostring_rgb() pygame.init() screen = pygame.display.get_surface() size = canvas.get_width_height() surf = pygame.image.fromstring(raw_data, size, "RGB") screen.blit(surf, (800, 200)) area = pygame.Rect(800, 0, 600, 700) pygame.display.update(area) pylab.close('all')
def getRawData(fig): canvas = agg.FigureCanvasAgg(fig) canvas.draw() renderer = canvas.get_renderer() raw_data = renderer.tostring_rgb() size = canvas.get_width_height() return raw_data, size
def script_init(sbj_id, day, disconnect_file): #Colors green = (0, 200, 0) labels, ratios, fig, pixel_points = rc.main(sbj_id, day) all_markers = {} start_time, end_time, start, end = get_disconnected_times(disconnect_file) for i in xrange(len(labels)): marker_cur = Marker(labels[i], ratios[i], pixel_points[i], start_time + timedelta(seconds=i)) if int(pixel_points[i][0]) not in all_markers: all_markers[int(pixel_points[i][0])] = {} if int(pixel_points[i][1]) not in all_markers[int(pixel_points[i][0])]: all_markers[int(pixel_points[i][0])][int(pixel_points[i][1])] = [] all_markers[int(pixel_points[i][0])][int( pixel_points[i][1])].append(marker_cur) canvas = agg.FigureCanvasAgg(fig) canvas.draw() renderer = canvas.get_renderer() raw_data = renderer.tostring_rgb() window = pygame.display.set_mode((1280, 480), pygame.locals.DOUBLEBUF) screen = pygame.display.get_surface() size = canvas.get_width_height() surf = pygame.image.fromstring(raw_data, size, "RGB") screen.blit(surf, (0, 0)) pygame.draw.rect(screen, green, (0, 0, 80, 40)) TextSurf, TextRect = text_objects("Restart", pygame.font.Font('freesansbold.ttf', 20)) TextRect.center = ((40), (20)) screen.blit(TextSurf, TextRect) pygame.display.flip() return all_markers, screen
def Plot_mean_std(mean, std, layer): fig = figure.Figure(figsize=(20, 20)) canvas = backend_agg.FigureCanvasAgg(fig) ax = fig.add_subplot(121) sns.distplot(mean, label='mean', hist=False, color="g", kde_kws={"shade": True}, ax=ax) ax1 = fig.add_subplot(122) sns.distplot(std, label='std', hist=False, color="g", kde_kws={"shade": True}, ax=ax1) ax.set_xlabel('Weight value') ax.set_ylabel('Density') ax.legend() fig.tight_layout() fname = os.path.join(self.FLAGS.data_dir, (layer[0].split('/')[-2] + "_Mean_STD_Plot.png")) canvas.print_figure(fname, format="png") return
def cli(): args = get_args() table = pandas.read_table(args.table, sep=" ") fig = matplotlib.figure.Figure(figsize=(6,15)) agg.FigureCanvasAgg(fig) multibarchart(fig, table) fig.savefig("report")
def create_canvas(self, rang, function, size, pos, surface): fig = pylab.figure( figsize=list(size), # Inches dpi=1, facecolor=( 0.0, 0.0, 0.0, 1.0 ) # 100 dots per inch, so the resulting buffer is 400x400 pixels ) ax = fig.gca() ax.set_axis_off() ax.set_facecolor((0.0, 1.0, 0.0, 1.0)) ax.plot(rang, function, linewidth=100) canvas = agg.FigureCanvasAgg(fig) canvas.draw() s = canvas.get_width_height() renderer = canvas.get_renderer() raw_data = renderer.tostring_argb() id_ = code_generator(6) self.requests.append({ "data": raw_data, "size": s, "pos": pos, "id": id_, "surface": surface }) return id_
def graphic(): global time0, success, miss_prev, hit_prev, hit, miss, B, fig, graf, canvas, renderer, raw_data, surf if pygame.time.get_ticks() - time0 > 2000: time0 = pygame.time.get_ticks() if (hit + miss - hit_prev - miss_prev) == 0: success = 0 else: success = 100 * (hit - hit_prev) / (hit + miss - hit_prev - miss_prev) sdvig(success) miss_prev = miss hit_prev = hit B = [(hit * 100) / (hit + miss)] * 20 fig = pylab.figure( figsize=[6, 4], # Inches dpi=200 ) # 100 dots per inch, so the resulting buffer is 400x400 pixels matplotlib.pyplot.xlabel(r'Время') matplotlib.pyplot.ylabel(r"Успешность") graf = fig.gca() graf.plot(B, color='g') graf.plot(A, color='b') canvas = agg.FigureCanvasAgg(fig) canvas.draw() renderer = canvas.get_renderer() raw_data = renderer.tostring_rgb() surf = pygame.image.fromstring(raw_data, size, "RGB")
def plot_weight_posteriors(names, qm_vals, qs_vals, fname): """Save a PNG plot with histograms of weight means and stddevs. Args: names: A Python `iterable` of `str` variable names. qm_vals: A Python `iterable`, the same length as `names`, whose elements are Numpy `array`s, of any shape, containing posterior means of weight varibles. qs_vals: A Python `iterable`, the same length as `names`, whose elements are Numpy `array`s, of any shape, containing posterior standard deviations of weight varibles. fname: Python `str` filename to save the plot to. """ fig = figure.Figure(figsize=(6, 3)) canvas = backend_agg.FigureCanvasAgg(fig) ax = fig.add_subplot(1, 2, 1) for n, qm in zip(names, qm_vals): sns.distplot(qm.flatten(), ax=ax, label=n) ax.set_title("weight means") ax.set_xlim([-1.5, 1.5]) ax.legend() ax = fig.add_subplot(1, 2, 2) for n, qs in zip(names, qs_vals): sns.distplot(qs.flatten(), ax=ax) ax.set_title("weight stddevs") ax.set_xlim([0, 1.]) fig.tight_layout() canvas.print_figure(fname, format="png") print("saved {}".format(fname))
def pygame_loop(prediction, img): if prediction <= 10: speed_label = myFont.render('Slow', 1, white) elif prediction > 10 and prediction <= 25: speed_label = myFont.render('Medium', 1, white) elif prediction > 25 and prediction <= 40: speed_label = myFont.render('Fast', 1, white) else: speed_label = myFont.render('Very Fast', 1, white) A.append(prediction) line1.set_ydata(A) line1.set_xdata(range(len(A))) ax.relim() ax.autoscale_view() canvas = agg.FigureCanvasAgg(fig) canvas.draw() renderer = canvas.get_renderer() raw_data = renderer.tostring_rgb() size = canvas.get_width_height() surf = pygame.image.fromstring(raw_data, size, "RGB") screen.blit(surf, (0, 480)) # draw on pygame.surfarray.blit_array(camera_surface, img.swapaxes(0, 1)) screen.blit(camera_surface, (0, 0)) diceDisplay = myFont.render(str(prediction), 1, white) screen.blit(randNumLabel, (50, 420)) screen.blit(speed_label, (300, 420)) screen.blit(diceDisplay, (50, 450)) clock.tick(60) pygame.display.flip()
def DrawMask(GenMask=False): sz = 6 gd = 40 pygame.draw.rect( DISPLAYSURF, BG, (0, WINDOW_HEIGHT * .25, WINDOW_WIDTH, WINDOW_HEIGHT * .55)) matrix = np.random.uniform(50, 30, gd * gd).reshape((gd, gd)) fig = pylab.figure(figsize=(sz, sz), dpi=100) ax = fig.gca() ax.set_axis_off() ax.matshow(matrix, cmap=plt.cm.binary) bg = BG[0] / 255. fig.patch.set_facecolor(str(bg)) canvas = agg.FigureCanvasAgg(fig) canvas.draw() renderer = canvas.get_renderer() raw_data = renderer.tostring_rgb() size = canvas.get_width_height() surf = pygame.image.fromstring(raw_data, size, "RGB") screen = DISPLAYSURF if GenMask: plt.close('all') return (surf, sz * 50) screen.blit(surf, (WINDOW_WIDTH * .5 - sz * 50, WINDOW_HEIGHT * .5 - sz * 50)) update() plt.close('all')
def add_figure(self, tag, figure, step=None, close=True): """ Logs a Matplotlib figure. Example: ```python with Logger() as logger: for trial in range(100): simulate(1000.0) fig = plt.figure() plt.plot(pop.r) logger.add_figure("Activity", fig, trial) ``` :param tag: name of the image in tensorboard. :param figure: a list or 1D numpy array of values. :param step: time index. :param close: whether the logger will close the figure when done (default: True). """ import matplotlib.pyplot as plt import matplotlib.backends.backend_agg as plt_backend_agg canvas = plt_backend_agg.FigureCanvasAgg(figure) canvas.draw() data = np.frombuffer(canvas.buffer_rgba(), dtype=np.uint8) w, h = figure.canvas.get_width_height() image_hwc = data.reshape([h, w, 4])[:, :, 0:3] image_chw = np.moveaxis(image_hwc, source=2, destination=0) if close: plt.close(figure) self._summary.add_image(tag, image_chw, step)
def draw_fuelusing(): color_back_fig = (20 / 255, 20 / 255, 20 / 255) mpl.rcParams.update({ "lines.color": "white", "patch.edgecolor": "white", "text.color": "white", "axes.facecolor": color_back_fig, "axes.edgecolor": "lightgray", "axes.labelcolor": "white", "xtick.color": "white", "ytick.color": "white", "grid.color": "lightgray", "figure.facecolor": color_back_fig, "figure.edgecolor": "black", "savefig.facecolor": "black", "savefig.edgecolor": "black" }) fig, ax = plt.subplots() x = numpy.linspace(0, 2, 10) plt.plot(consumptionx, consumptiony, label="Fogyasztás") plt.xlabel('Idő (sec)') plt.ylabel('Fogyasztás (l/100km)') plt.title("Átlagfogyasztás") plt.legend() canvas = agg.FigureCanvasAgg(fig) canvas.draw() renderer = canvas.get_renderer() size = canvas.get_width_height() return pygame.image.frombuffer(renderer.tostring_rgb(), size, "RGB")
def run(self): running = True self.screen.fill(BLACK) while running: for event in pygame.event.get(): if event.type == pygame.QUIT: running = False if event.type == pygame.KEYDOWN: running = False self.grid.particle_to_density() fig = plt.figure(figsize = (SCREENSIZE[0]/100.0,SCREENSIZE[1]/100.0), dpi = 100, frameon = False) #fig, ax = plt.subplots(1) fig.subplots_adjust(left=0,right=1,bottom=0,top=1) plt.imshow(self.grid.grid.T/10**8, cmap = 'magma', vmin = 0, vmax = 2) plt.axis('off') plt.axis('tight') canvas = agg.FigureCanvasAgg(fig) plt.close() canvas.draw() renderer = canvas.get_renderer() raw_data = renderer.tostring_rgb() surf = pygame.image.fromstring(raw_data, canvas.get_width_height(), "RGB") self.screen.blit(surf, (0,0)) self.grid.calculate_potential() self.grid.calculate_force() self.grid.update() pygame.display.flip() pygame.quit() sys.exit()