def _generate_histogram(m): # Make a 350px by 32px image for a slider background fig = Figure(figsize=(3.5,0.32), dpi=100, tight_layout=False) # This is required, even though we don't explicitly use the canvas. canvas = FigureCanvasAgg(fig) ax = fig.add_subplot(1,1,1) vrange = float(m.bounds[1] - m.bounds[0]) num_bins = np.ceil(vrange / m.step) + 1 if np.isnan(num_bins): ax.hist(m.arr) elif num_bins > 300: ax.hist(m.arr, 300, range=m.bounds) else: ax.hist(m.arr, int(num_bins), range=m.bounds) ax.axis('off') fig.subplots_adjust(top=1,bottom=0,right=1,left=0,hspace=0,wspace=0) ax.margins(0, 0) ax.xaxis.set_major_locator(NullLocator()) ax.yaxis.set_major_locator(NullLocator()) # save it as a base64 encoded string img_data = BytesIO() fig.savefig(img_data, format='png', bbox_inches='tight', pad_inches=0) return b64encode(img_data.getvalue())
def draw_figure(canvas, figure, loc=(0, 0)): """ Draw a matplotlib figure onto a Tk canvas loc: location of top-left corner of figure on canvas in pixels. Inspired by matplotlib source: lib/matplotlib/backends/backend_tkagg.py """ figure_canvas_agg = FigureCanvasAgg(figure) figure_canvas_agg.draw() figure_x, figure_y, figure_w, figure_h = figure.bbox.bounds figure_w, figure_h = int(figure_w), int(figure_h) photo = tk.PhotoImage(master=canvas, width=figure_w, height=figure_h) # Position: convert from top-left anchor to center anchor canvas.create_image(loc[0] + figure_w / 2, loc[1] + figure_h / 2, image=photo) # Unfortunately, there's no accessor for the pointer to the native renderer tkagg.blit(photo, figure_canvas_agg.get_renderer()._renderer, colormode=2) # Return a handle which contains a reference to the photo object # which must be kept live or else the picture disappears return photo
def export_image(filename, format, figure, settings): oldSize = figure.get_size_inches() oldDpi = figure.get_dpi() figure.set_size_inches((settings.exportWidth, settings.exportHeight)) figure.set_dpi(settings.exportDpi) canvas = FigureCanvasAgg(figure) canvas.draw() renderer = canvas.get_renderer() if matplotlib.__version__ >= '1.2': buf = renderer.buffer_rgba() else: buf = renderer.buffer_rgba(0, 0) size = canvas.get_width_height() image = Image.frombuffer('RGBA', size, buf, 'raw', 'RGBA', 0, 1) image = image.convert('RGB') ext = File.get_type_ext(format, File.Types.IMAGE) image.save(filename, format=ext[1::], dpi=(settings.exportDpi, settings.exportDpi)) figure.set_size_inches(oldSize) figure.set_dpi(oldDpi)
def plot_LOSS(file_name, skip_points, train_loss_list, val_loss_list, norm_loss_list, abnorm_loss_list): import matplotlib.pyplot as plt from matplotlib.backends.backend_agg import FigureCanvasAgg from matplotlib.figure import Figure fig_size = (8, 6) fig = Figure(figsize=fig_size) file_name = file_name ax = fig.add_subplot(111) if len(train_loss_list) < skip_points: return ax.plot(train_loss_list[skip_points:]) ax.plot(val_loss_list[skip_points:]) ax.plot(norm_loss_list[skip_points:]) ax.plot(abnorm_loss_list[skip_points:]) title = os.path.basename(os.path.dirname(file_name)) ax.set_title(title) ax.set_xlabel('Iterations/100') ax.set_ylabel('MSE') ax.legend(['Train', 'Valid', 'T-norm', 'T-Abnorm']) ax.set_xlim([0, len(train_loss_list)]) canvas = FigureCanvasAgg(fig) canvas.print_figure(file_name, dpi=100)
def plot_hist(file_name, x, y): import matplotlib.pyplot as plt from matplotlib.backends.backend_agg import FigureCanvasAgg from matplotlib.figure import Figure kwargs = dict(alpha=0.6, bins=100, density=False, stacked=True) fig_size = (8, 6) fig = Figure(figsize=fig_size) file_name = file_name ax = fig.add_subplot(111) # x = np.exp(-x) # y = np.exp(-y) ax.hist(x, **kwargs, color='g', label='Norm') ax.hist(y, **kwargs, color='r', label='Anomaly') title = os.path.basename(os.path.dirname(file_name)) ax.set_title(title) ax.set_xlabel('Error') ax.set_ylabel('Frequency') ax.legend(['Norm', 'Anomaly']) ax.set_xlim( [np.min(np.concatenate([x, y])), np.max(np.concatenate([x, y]))]) canvas = FigureCanvasAgg(fig) canvas.print_figure(file_name, dpi=100)
def encode_plot(P, pad=None, pad_inches=0.1, bbox_inches=None): """ Convert a plot object to base64-encoded png format. pad is passed down to matplotlib's tight_layout; pad_inches and bbox_inches to savefig. The resulting object is a base64-encoded version of the png formatted plot, which can be displayed in web pages with no further intervention. """ from StringIO import StringIO from matplotlib.backends.backend_agg import FigureCanvasAgg from base64 import b64encode from urllib import quote virtual_file = StringIO() fig = P.matplotlib() fig.set_canvas(FigureCanvasAgg(fig)) if pad is not None: fig.tight_layout(pad=pad) fig.savefig(virtual_file, format='png', pad_inches=pad_inches, bbox_inches=bbox_inches) virtual_file.seek(0) return "data:image/png;base64," + quote(b64encode(virtual_file.buf))
def plot_prediction_zx(file_name, ph_vol, gt_vol, pr_vol, z_index, x_index): import matplotlib.pyplot as plt from matplotlib.backends.backend_agg import FigureCanvasAgg from matplotlib.figure import Figure import random z_index, x_index = z_index, x_index widths = [1, 1, 1] heights = [1, 0.34] gs_kw = dict(width_ratios=widths, height_ratios=heights) rows, cols, size = 2, 3, 5 fig = Figure(tight_layout=True, figsize=(size * cols, size * rows)) kx = fig.subplots(nrows=rows, ncols=cols, gridspec_kw=gs_kw) ax, bx, cx = kx[0, 0], kx[0, 1], kx[0, 2] ex, fx, gx = kx[1, 0], kx[1, 1], kx[1, 2] print(ph_vol.shape) cax = ax.imshow(ph_vol[z_index - 1:z_index + 2, :, :].transpose((1, 2, 0))) fig.colorbar(cax, ax=ax) cbx = bx.imshow(gt_vol[z_index - 1:z_index + 2, :, :].transpose((1, 2, 0))) fig.colorbar(cbx, ax=bx) ccx = cx.imshow(pr_vol[z_index - 1:z_index + 2, :, :].transpose((1, 2, 0))) fig.colorbar(ccx, ax=cx) ax.set_title('Phase (z={})'.format(z_index)) bx.set_title('GT fl') cx.set_title('Pred fl') ax.set_ylabel('x') ax.set_xlabel('y') cex = ex.imshow(ph_vol[:, x_index - 1:x_index + 2, :].transpose((0, 2, 1))) fig.colorbar(cex, ax=ex) cfx = fx.imshow(gt_vol[:, x_index - 1:x_index + 2, :].transpose((0, 2, 1))) fig.colorbar(cfx, ax=fx) cgx = gx.imshow(pr_vol[:, x_index - 1:x_index + 2, :].transpose((0, 2, 1))) fig.colorbar(cgx, ax=gx) ex.set_ylabel('z') ex.set_title('x={}'.format(x_index)) ex.set_xlabel('y') canvas = FigureCanvasAgg(fig) canvas.print_figure(file_name, dpi=60)
def _visualize(self, detection, image): """Generate a visual detection for a detection with matplotlib. Parameters ---------- - detection: dict A single Mask RCNN detection - image: ndarray Original image. Returns ---------- - vis_plt_detection: A visual detection. """ rospy.loginfo("Visualizing...") fig = Figure() canvas = FigureCanvasAgg(fig) axes = fig.gca() visualize.display_instances(image, detection['rois'], detection['masks'], detection['class_ids'], CLASS_NAMES, detection['scores'], ax=axes, class_colors=self._class_colors) fig.tight_layout() canvas.draw() vis_plt_detection = np.fromstring(canvas.tostring_rgb(), dtype='uint8') _, _, w, h = fig.bbox.bounds vis_plt_detection = vis_plt_detection.reshape((int(h), int(w), 3)) return vis_plt_detection
def make_plot(rm, r, nmin, b, f, kmax): from matplotlib.figure import Figure from matplotlib.backends.backend_agg import FigureCanvasAgg figure = Figure() canvas = FigureCanvasAgg(figure) ax = figure.add_subplot(111) for r1, nmin1, bias, gr in zip(r, nmin, b, f): lines = None for i in range(rm.power['k'].shape[1]): mask = rm.power['modes'][:, i] > 0 if i == 0: label='nmin = %d' % nmin1 else: label= None if lines is None: color = None else: color = lines.get_color() lines, = ax.plot(rm.power['k'][:, i][mask], (r1.power['power'].real / rm.power['power'].real)[:, i][mask], '.', color=color, alpha= 0.3 - 0.7 * i / rm.power['k'].shape[1]) lines, = ax.plot(rm.power['k'][:, i][mask], (bias + gr * r1.power['mu'] ** 2)[:, i][mask], label=label, color=lines.get_color()) ax.axvline(kmax, ls='--', color='k') ax.legend() ax.set_ylim(0, numpy.max(b) * 2) ax.set_xlim(1e-3, kmax * 8) ax.set_xscale('log') ax.set_yscale('linear') ax.set_xlabel('k h/Mpc') ax.set_ylabel('Px / Pa') return figure
def subplots(nrows=1, ncols=1, sharex=False, sharey=False, squeeze=True, subplot_kw=None, gridspec_kw=None, **fig_kw): """ Create a figure and a set of subplots, as in `pyplot.subplots()`. It works almost similar to `pyplot.subplots()`, but differ from it in that it does not involve any side effect as pyplot does (e.g. modifying thread states such as current figure or current subplot). (docstrings inherited from `matplotlib.pyplot.subplots`) """ FigureClass = fig_kw.pop('FigureClass', Figure) fig = FigureClass(**fig_kw) # attach a new Agg canvas if fig.canvas is None: FigureCanvasAgg(fig) # create subplots, e.g. fig.subplots() in matplotlib 2.1+ if not hasattr(fig, 'subplots'): fig.subplots = types.MethodType(mpl_figure.subplots, fig, FigureClass) axs = fig.subplots(nrows=nrows, ncols=ncols, sharex=sharex, sharey=sharey, squeeze=squeeze, subplot_kw=subplot_kw, gridspec_kw=gridspec_kw) return fig, axs
def save_plotSpectrum(y, Fs, image_name): """ Plots a Single-Sided Amplitude Spectrum of y(t) """ fig = Figure(linewidth=0.0) fig.set_size_inches(fig_width, fig_length, forward=True) Figure.subplots_adjust(fig, left=fig_left, right=fig_right, bottom=fig_bottom, top=fig_top, hspace=fig_hspace) n = len(y) # length of the signal _subplot = fig.add_subplot(2, 1, 1) print "Fi" _subplot.plot(arange(0, n), y) xlabel('Time') ylabel('Amplitude') _subploti_2 = fig.add_subplot(2, 1, 2) k = arange(n) T = n / Fs frq = k / T # two sides frequency range frq = frq[range(n / 2)] # one side frequency range Y = fft(y) / n # fft computing and normalization Y = Y[range(n / 2)] _subplot_2.plot(frq, abs(Y), 'r') # plotting the spectrum xlabel('Freq (Hz)') ylabel('|Y(freq)|') print "here" canvas = FigureCanvasAgg(fig) if '.eps' in outfile_name: canvas.print_eps(outfile_name, dpi=110) if '.png' in outfile_name: canvas.print_figure(outfile_name, dpi=110)
def print_drp(self, event): ''' Plots a red circle and shows current DRP. ''' locX, locY = event.x, event.y x = np.clip(locX / self.sc, 0, self.ry - 1).astype('int') y = np.clip(locY / self.sc, 0, self.rx - 1).astype('int') # Display locator (red circle) self.canvas.delete(self.locator) self.locator = self.canvas.create_oval( locX - 5, locY - 5, locX + 5, locY + 5, outline='red', width=2, ) # Print DRP in canvas drp = self.data[y, x].reshape((self.s0, self.s1)).T fig = plot3D(drp, self.s0, self.s1) plt.close() # ### OPTIONAL: PRINT DRP IN CONSOLE # fig, ax = plt.subplots(figsize=(8,8), dpi=200) # ax.imshow(drp.T, cmap=plt.cm.gray) # ax.axis('off') # plt.show() self.drpfixim = FigureCanvasAgg(fig) s, (width, height) = self.drpfixim.print_to_buffer() self.drpfixim = np.frombuffer(s, np.uint8).reshape((height, width, 4)) self.host_canvas.show_rgba(self.drpfixim) self.master_object.nbk.select(0)
def pcolormesh_response(lon, lat, data, request, dpi=80): bbox, width, height, colormap, cmin, cmax, crs = _get_common_params( request) EPSG4326 = pyproj.Proj(init='EPSG:4326') x, y = pyproj.transform(EPSG4326, crs, lon, lat) fig = Figure(dpi=dpi, facecolor='none', edgecolor='none') fig.set_alpha(0) fig.set_figheight(height / dpi) fig.set_figwidth(width / dpi) ax = fig.add_axes([0., 0., 1., 1.], xticks=[], yticks=[]) ax.set_axis_off() if request.GET['logscale'] is True: norm_func = mpl.colors.LogNorm else: norm_func = mpl.colors.Normalize if cmin and cmax: data[data > cmax] = cmax data[data < cmin] = cmin norm = norm = norm_func(vmin=cmin, vmax=cmax) else: norm = norm_func() masked = np.ma.masked_invalid(data) ax.pcolormesh(x, y, masked, norm=norm, cmap=colormap) ax.set_xlim(bbox.minx, bbox.maxx) ax.set_ylim(bbox.miny, bbox.maxy) ax.set_frame_on(False) ax.set_clip_on(False) ax.set_position([0., 0., 1., 1.]) canvas = FigureCanvasAgg(fig) response = HttpResponse(content_type='image/png') canvas.print_png(response) return response
def contourf_response(lon, lat, data, request, dpi=80 ): params = _get_common_params(request) bbox, width, height, colormap, cmin, cmax, crs = params EPSG4326 = pyproj.Proj(init='EPSG:4326') x, y = pyproj.transform(EPSG4326, crs, lon, lat) fig = Figure(dpi=dpi, facecolor='none', edgecolor='none') fig.set_alpha(0) fig.set_figheight(height/dpi) fig.set_figwidth(width/dpi) ax = fig.add_axes([0., 0., 1., 1.], xticks=[], yticks=[]) ax.set_axis_off() cmap = mpl.cm.get_cmap(colormap) if cmin and cmax: data[data > cmax] = cmax data[data < cmin] = cmin bounds = np.linspace(cmin, cmax, 15) norm = mpl.colors.BoundaryNorm(bounds, cmap.N) bounds = np.linspace(cmin, cmax, 15) else: norm = None ax.contourf(x, y, data, vmin=5, vmax=30, norm=norm) ax.set_xlim(bbox.minx, bbox.maxx) ax.set_ylim(bbox.miny, bbox.maxy) ax.set_frame_on(False) ax.set_clip_on(False) ax.set_position([0., 0., 1., 1.]) canvas = FigureCanvasAgg(fig) response = HttpResponse(content_type='image/png') canvas.print_png(response) return response
def plot(): import matplotlib as mpl import matplotlib.backends.tkagg as tkagg from matplotlib.backends.backend_agg import FigureCanvasAgg from matplotlib.backends.backend_tkagg import (FigureCanvasTkAgg, NavigationToolbar2Tk) import pandas as pd fig = mpl.figure.Figure(figsize=(3, 2)) ax = fig.add_subplot(111) figure_canvas_agg = FigureCanvasAgg(fig) series = pandas.Series(data) dplt = series.plot(ax=ax) figure_canvas_agg.draw() figure_x, figure_y, figure_w, figure_h = fig.bbox.bounds figure_w, figure_h = int(figure_w), int(figure_h) global the_fig_photo the_fig_photo = tk.PhotoImage(master=the_canvas, width=figure_w, height=figure_h) # Position: convert from top-left anchor to center anchor loc = (0, 0) the_canvas.delete("all") the_canvas.create_image(loc[0] + figure_w / 2, loc[1] + figure_h / 2, image=the_fig_photo) tkagg.blit(the_fig_photo, figure_canvas_agg.get_renderer()._renderer, colormode=2) return the_fig_photo # XXX: has to be held
def provincia(): datamodel.updater(data) # Call to update fig = Figure(figsize=(15, 6)) ax = fig.add_subplot(1, 1, 1) provs = [] provs_values = [] for i, v in enumerate(data.locations): if v[0] != None: provs.append(str(v[0])) else: provs.append('Desconocido') provs_values.append(v[1]) label = "{} ({}%)".format( v[1], round(v[1] * 100 / data.total_diagnosticados, 2)) ax.annotate(label, (v[1], i), textcoords='offset points', xytext=(2, -3), ha='left') ax.barh(provs, provs_values, color=red) ax.set_title('Casos detectados por provincias', fontsize=20) FigureCanvasAgg(fig).print_png('provincias.png') apiurl = config.SERVER_URI + '/provincias' watermark_text('provincias.png', 'provincias.png', apiurl, (0, 0)) return send_file('provincias.png')
def draw_four_up_histogram(dataset) : # draw a 2x2 plot of # fullpage+rast 300+rast # fullpage+vor 300_vor outfilename = "{0}_2x2.png".format(dataset) figure_label_iter = iter(("(a)","(b)","(c)","(d)")) subplot_counter = 1 for algo in algorithm_list : for stripsize in ("fullpage","300") : fig = Figure() fig.suptitle(dataset) metrics = datfile.load_metrics( dataset=dataset, stripsize=stripsize, algorithm=algo) ax = fig.add_subplot(111) ax.hist(metrics[np.nonzero(np.nan_to_num(metrics))],bins=25) # ax.hist(metrics[np.nonzero(np.nan_to_num(metrics))],bins=25,normed=True) # ax.set_title("{0} {1} {2}".format(figure_label_iter.next(),algo,stripsize)) ax.set_xlabel( "Metric" ) ax.set_xlim(0,1.0) subplot_counter += 1 fig.tight_layout(pad=2.0) outfilename = "{0}_{1}_{2}_histo.png".format(dataset,stripsize,algo) canvas = FigureCanvasAgg(fig) canvas.print_figure(outfilename) print "wrote", outfilename stretch_width( outfilename )
def GET(self, from_date_str=None): default_from_date = TradeTime.get_latest_trade_date() - datetime.timedelta(60) if from_date_str is None or from_date_str == '': from_date = default_from_date else: try: input_from_date = datetime.datetime.strptime(from_date_str, '%Y-%m-%d').date() from_date = TradeTime.get_from_date_by_window(22, input_from_date) except Exception: from_date = default_from_date records_svxy = YahooEquityDAO().get_all_equity_price_by_symbol('SVXY', from_date.strftime('%Y-%m-%d'), 'Closeprice') dates = map(lambda x: x[0], records_svxy) price_svxy = map(lambda x: x[1], records_svxy) # shift append_dates = TradeTime.generate_dates(dates[-1], dates[-1] + datetime.timedelta(days=50)) dates = dates[21:] + append_dates[1:22] price_svxy = price_svxy[21:] + [price_svxy[-1]] * 21 if from_date < default_from_date: dates = dates[:42] price_svxy = price_svxy[:42] fig = Figure(figsize=[24, 4]) ax = fig.add_axes([.1, .1, .8, .8]) ax.plot(dates, price_svxy, label='SVXY') ax.legend(loc='upper left') ax.grid() ax.xaxis.set_major_formatter(DateFormatter('%y%m%d')) ax.set_xticks(dates) for tick in ax.get_xticklabels(): tick.set_rotation(45) canvas = FigureCanvasAgg(fig) buf = cStringIO.StringIO() canvas.print_png(buf) data = buf.getvalue() return data
def img_home(request): import matplotlib.pyplot as plt import cartopy.crs as ccrs import cartopy.feature as cfeature fig = plt.figure(figsize=(12, 8)) FigureCanvasAgg(fig) buf = io.BytesIO() ax = fig.add_subplot(1, 1, 1, projection=ccrs.PlateCarree()) ax.set_global() ax.stock_img() ax.add_feature(cfeature.LAND, color='wheat') ax.add_feature(cfeature.OCEAN, color='skyblue') ax.add_feature(cfeature.COASTLINE, linestyle='-', lw=1) ax.add_feature(cfeature.BORDERS, linestyle=':') ax.add_feature(cfeature.LAKES, alpha=0.5, color='y') ax.add_feature(cfeature.RIVERS, color='skyblue', alpha=0.3) ax.plot(18.4241, -33.9249, 'o', transform=ccrs.Geodetic(), markersize=7, color='r', alpha=0.3) plt.text(18.4241, -33.9249, 'Cape Town', size=10, color='indigo', horizontalalignment='left', transform=ccrs.Geodetic()) plt.savefig(buf, format='png') plt.close(fig) response = HttpResponse(buf.getvalue(), content_type='image/png') return response
def graph_cpu(graph_type): fig = plt.figure(figsize=(9, 8)) plt.xlabel("time") plt.xticks(rotation=45) if (graph_type == "temp"): plt.title('temperature') plt.ylabel("temperature [℃]") elif (graph_type == "clock"): plt.title('clock') plt.ylabel("clock [GHz]") elif (graph_type == "volt"): plt.title('volt') plt.ylabel("volt [v]") elif (graph_type == "arm"): plt.title('arm') plt.ylabel("arm [MB]") elif (graph_type == "gpu"): plt.title('gpu') plt.ylabel("gpu [MB]") try: Data = get_graph_Data(graph_type) plt.plot(Data[0], Data[1]) # canvasにプロットした画像を出力 canvas = FigureCanvasAgg(fig) png_output = BytesIO() canvas.print_png(png_output) data = png_output.getvalue() # HTML側に渡すレスポンスを生成する response = make_response(data) response.headers['Content-Type'] = 'image/png' response.headers['Content-Length'] = len(data) return response except: flash("graph error") update_CPU() graph_cpu(graph_type)
def encode_plot(P, pad=None, pad_inches=0.1, bbox_inches=None, remove_axes=False, transparent=False, axes_pad=None): """ Convert a plot object to base64-encoded png format. pad is passed down to matplotlib's tight_layout; pad_inches and bbox_inches to savefig. The resulting object is a base64-encoded version of the png formatted plot, which can be displayed in web pages with no further intervention. """ from io import BytesIO as IO from matplotlib.backends.backend_agg import FigureCanvasAgg from base64 import b64encode from urllib.parse import quote virtual_file = IO() fig = P.matplotlib(axes_pad=axes_pad) fig.set_canvas(FigureCanvasAgg(fig)) if remove_axes: for a in fig.axes: a.axis('off') if pad is not None: fig.tight_layout(pad=pad) fig.savefig(virtual_file, format='png', pad_inches=pad_inches, bbox_inches=bbox_inches, transparent=transparent) virtual_file.seek(0) buf = virtual_file.getbuffer() return "data:image/png;base64," + quote(b64encode(buf))
def test(): datamodel.updater(data) # Call to update fig = Figure(figsize=(15, 6)) (ax1, ax2) = fig.subplots(1, 2) # Test realizados xss = [str(k) for k in range(12, data.cant_days + 1)] xs = range(0, data.cant_days + 1 - 12) ax1.bar(xss, data.cant_tests, color=red) ax1.bar(xss, data.detected_acc, color=yellow) for x, y in zip(xs, data.cant_tests): label = "{}".format(y) ax1.annotate(label, (x, y), textcoords='offset points', xytext=(0, 4), ha='center') ax1.set_title('Tests acumulados por d铆a') # Proporci贸n entre casos confirmados y test realizados ax2.bar([str(k) for k in range(12, data.cant_days + 1)], data.prop_test_vs_detected, color=red) ax2.set_title('Proporci贸n detectados/tests realizados') FigureCanvasAgg(fig).print_png('tests.png') apiurl = config.SERVER_URI + '/test' watermark_text('tests.png', 'tests.png', apiurl, (0, 0)) return send_file('tests.png')
def matplotlib_figure(width, height): """ @brief Create a Matplotlib figure with specified width and height for rendering @param w Width of desired plot @param h Height of desired plot @return A Matplotlib figure """ try: from matplotlib.backends.backend_agg import FigureCanvasAgg except: paraview.print_error( "Error: Cannot import matplotlib.backends.backend_agg.FigureCanvasAgg" ) try: from matplotlib.figure import Figure except: paraview.print_error("Error: Cannot import matplotlib.figure.Figure") figure = Figure() figureCanvas = FigureCanvasAgg(figure) figure.set_dpi(72) figure.set_size_inches(float(width) / 72.0, float(height) / 72.0) return figure
def makeTextGraph(self, text='Empty image'): """ Make an empty text image """ self.figure = Figure() figure = self.figure self.canvas = FigureCanvasAgg(figure) prefs = self.prefs dpi = prefs['dpi'] width = float(prefs['width']) height = float(prefs['height']) width_inch = width / dpi height_inch = height / dpi figure.set_size_inches(width_inch, height_inch) figure.set_dpi(dpi) figure.set_facecolor('white') text_size = prefs.get('text_size', 12) figure.text(.5, .5, text, horizontalalignment='center', size=pixelToPoint(text_size, dpi))
def spec_plot(x, y, img, file_name, figure_size=(10, 5), transparent=False): import matplotlib import matplotlib.figure import matplotlib.cm from matplotlib.backends.backend_agg import FigureCanvasAgg figure_size = None F = first_moment_analysis(x, y) fig = matplotlib.figure.Figure(figure_size, 144, linewidth=0, facecolor="white") if transparent: self.figure.figurePatch.set_alpha(0.0) canvas = FigureCanvasAgg(fig) p = fig.add_subplot(211) p.set_position([0.1, 0.3, 0.8, 0.6]) p.plot(x, y, '-') fm = F.as_trace() p.plot(fm[0], fm[1], "r-") p.set_xlim(x[0], x[-1]) p.set_xlabel("position") p.set_ylabel("intensity") p.set_title("X-ray emission spectrum, first moment=%.2f" % (F.first_moment)) p2 = fig.add_subplot(212) p2.set_position([0.1, 0.05, 0.8, 0.2]) im = p2.imshow(img.as_numpy_array(), cmap='spectral') im.set_interpolation("none") position = fig.add_axes([0.91, 0.1, 0.015, 0.35]) # p2.imshow(img.as_numpy_array(), cmap=matplotlib.cm.gist_yarg) p3 = fig.colorbar(im, orientation='vertical', cax=position) # p2.set_position([0.1, 0.05, 0.8, 0.2]) canvas.draw() fig.savefig(file_name, dpi=200, format="png")
def plot(): """ SQL query and plot graph Connect to the Azure SQL Database and making a query. Then use the query result to plot a graph. This graph will be used by the hello.html. """ # Connect to the Azure SQL database driver, server, db, uid, pwd = configuration() conn, cursor = sqldb_conn(driver, server, db, uid, pwd) # Making the SQL query query = fetch_query() # Putting the result in a dataframe df = pd.read_sql(query, conn) # Call the create_figure method from graph.py to plot a graph fig = create_figure(df) output = io.BytesIO() FigureCanvasAgg(fig).print_png(output) return Response(output.getvalue(), mimetype='image/png')
def mathTex_to_QPixmap(mathTex, font_size): #---- set up a mpl figure instance ---- fig = mpl.figure.Figure() fig.patch.set_facecolor('none') fig.set_canvas(FigureCanvasAgg(fig)) renderer = fig.canvas.get_renderer() #---- plot the mathTex expression ---- ax = fig.add_axes([0, 0, 1, 1]) ax.axis('off') ax.patch.set_facecolor('none') t = ax.text(0, 0, mathTex, ha='left', va='bottom', fontsize=font_size) #---- fit figure size to text artist ---- fwidth, fheight = fig.get_size_inches() fig_bbox = fig.get_window_extent(renderer) text_bbox = t.get_window_extent(renderer) tight_fwidth = text_bbox.width * fwidth / fig_bbox.width tight_fheight = text_bbox.height * fheight / fig_bbox.height fig.set_size_inches(tight_fwidth, tight_fheight) #---- convert mpl figure to QPixmap ---- buf, size = fig.canvas.print_to_buffer() qimage = QtGui.QImage.rgbSwapped(QtGui.QImage(buf, size[0], size[1], QtGui.QImage.Format_ARGB32)) qpixmap = QtGui.QPixmap(qimage) return qpixmap
def plot_dsc(dsc_dist): y_positions = np.arange(len(dsc_dist)) dsc_dist = sorted(dsc_dist.items(), key=lambda x: x[1]) values = [x[1] for x in dsc_dist] labels = [x[0] for x in dsc_dist] labels = ["_".join(l.split("_")[1:-1]) for l in labels] fig = plt.figure(figsize=(12, 8)) canvas = FigureCanvasAgg(fig) plt.barh(y_positions, values, align="center", color="skyblue") plt.yticks(y_positions, labels) plt.xticks(np.arange(0.0, 1.0, 0.1)) plt.xlim([0.0, 1.0]) plt.gca().axvline(np.mean(values), color="tomato", linewidth=2) plt.gca().axvline(np.median(values), color="forestgreen", linewidth=2) plt.xlabel("Dice coefficient", fontsize="x-large") plt.gca().xaxis.grid(color="silver", alpha=0.5, linestyle="--", linewidth=1) plt.tight_layout() canvas.draw() plt.close() s, (width, height) = canvas.print_to_buffer() return np.fromstring(s, np.uint8).reshape((height, width, 4))
def plot_psnr_histogram(file_name, psnr_list1, psnr_list2, rho_list1, rho_list2): import matplotlib.pyplot as plt from matplotlib.backends.backend_agg import FigureCanvasAgg from matplotlib.figure import Figure kwargs = dict(alpha=0.7, bins=12, density= False, stacked=True) rows, cols, size = 1,2,6; font_size = 20 fig = Figure(tight_layout=True,figsize=(size*cols, size*rows)); ax = fig.subplots(rows,cols) ax[0].hist(psnr_list1, **kwargs, color='r', label='fl1') # PSNR for channel 1 ax[0].hist(psnr_list2, **kwargs, color='g', label='fl2') # PSNR for channel 2 ax[0].legend(['fl1_average: {:.2f}'.format(np.mean(psnr_list1)), 'fl2_average: {:.2f}'.format(np.mean(psnr_list2))],fontsize=font_size-2) ax[0].set_title('PSNR distribution', fontsize =font_size) ax[0].set_ylabel('Count', fontsize =font_size);ax[0].set_xlabel('PSNR', fontsize =font_size); ax[0].set_xlim([np.min(np.concatenate([psnr_list1,psnr_list2]))-5, np.max(np.concatenate([psnr_list1,psnr_list2]))]) # ax[0].set_xlim([np.min(np.concatenate([psnr_list1,psnr_list2])), np.max(np.concatenate([psnr_list1,psnr_list2]))]) ax[0].tick_params(axis='x', labelsize=font_size-2); ax[0].tick_params(axis='y', labelsize=font_size-2) # kwargs = dict(alpha=0.9, bins=10, density= False, stacked=True) ax[1].hist(rho_list1, **kwargs, color='r', label='fl1') # PSNR for channel 1 ax[1].hist(rho_list2, **kwargs, color='g', label='fl2') # PSNR for channel 2 ax[1].set_title(r'$\rho$ distribution', fontsize =font_size) ax[1].set_ylabel('Count', fontsize =font_size);ax[1].set_xlabel(r'$\rho$', fontsize =font_size); ax[1].tick_params(axis='x', labelsize=font_size-2); ax[1].tick_params(axis='y', labelsize=font_size-2) ax[1].set_xlim([0,1.0]) ax[1].legend(['fl1_average: {:.4f}'.format(np.mean(rho_list1)), 'fl2_average: {:.4f}'.format(np.mean(rho_list2))],fontsize=font_size-2) canvas = FigureCanvasAgg(fig); canvas.print_figure(file_name, dpi=80)
def write_report(reportname, r): from matplotlib.figure import Figure from matplotlib.backends.backend_agg import FigureCanvasAgg fig = Figure(figsize=(6, 6)) ax = fig.add_subplot(111) ax.plot(r.Ppm.power['k'], r.Ppm.power['power'] / r.Pl.power['power'] - 1, label='Multistep') ax.plot(r.P1lpt.power['k'], r.P1lpt.power['power'] / r.Pl.power['power'] - 1, label='1-LPT') ax.set_xscale('log') ax.axhline(0.0, color='k', ls='--') ax.set_ylim(-0.03, 0.03) ax.set_xlim(0.003, 0.04) ax.grid() ax.set_xlabel('k [h/Mpc]') ax.set_ylabel(r'P(k) / <P_l(k)>') ax.set_title(r"Comparing Linear theory and 1-LPT") ax.legend() # numpy.savez(reportname.replace('.png', '.npz', r.__dict__) canvas = FigureCanvasAgg(fig) fig.savefig(reportname)