def __init__(self, data_sets: list): # Verify user input num_dims = len(data_sets[0]) # dimensions if num_dims < 2: raise ValueError('Must supply data with more than one dimension.') # Setup figure and axes x = range(num_dims) fig = mpl_figure.Figure() axes = list() for idx in range(num_dims - 1): axes.append(fig.add_subplot(1, num_dims - 1, idx + 1)) # Store, initialize values self.fig = fig self._axes = axes self._ax_color_bar = None self._x = x self._data_sets = None self._data_sets_info = None self._num_dims = num_dims self._colors = None self._scores = None self._scores_norm_min = None self._scores_norm_max = None self._color_style = None self._color_map_norm = None self._use_variable_line_width = False self._sorted_scores_indices = None self._set_data(data_sets)
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 _setup_figure(self, img): """ Args: Same as in :meth:`__init__()`. Returns: fig (matplotlib.pyplot.figure): top level container for all the image plot elements. ax (matplotlib.pyplot.Axes): contains figure elements and sets the coordinate system. """ fig = mplfigure.Figure(frameon=False) self.dpi = fig.get_dpi() # add a small 1e-2 to avoid precision lost due to matplotlib's truncation # (https://github.com/matplotlib/matplotlib/issues/15363) fig.set_size_inches( (self.width * self.scale + 1e-2) / self.dpi, (self.height * self.scale + 1e-2) / self.dpi, ) self.canvas = FigureCanvasAgg(fig) # self.canvas = mpl.backends.backend_cairo.FigureCanvasCairo(fig) ax = fig.add_axes([0.0, 0.0, 1.0, 1.0]) ax.axis("off") ax.set_xlim(0.0, self.width) ax.set_ylim(self.height) self.fig = fig self.ax = ax
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 dt_plot(key, denominator_coords, denominator_data, numerator_coords, numerator_data): fig = figure.Figure(figsize=(4, 4 / golden_ratio)) FigureCanvas(fig) axes = fig.add_axes((.14, .15, .98 - .14, .90 - .15)) denominator_data = numpy.nan_to_num(denominator_data) numerator_data = numpy.nan_to_num(numerator_data) if numpy.any(denominator_data): axes.plot(denominator_coords, denominator_data, "k-", label="Background") if numpy.any(numerator_data): axes.plot(numerator_coords, numerator_data, "r-", label="Injections") ymin, ymax = axes.get_ylim() axes.set_ylim((max(ymin, ymax - 14), ymax)) axes.legend(loc="upper left") instrument1, instrument2 = key.split("-")[:2] axes.set_title(r"%s--%s Arrival Time Difference Distribution" % (instrument1, instrument2)) axes.set_ylabel(r"$\ln P$") axes.set_xlabel(r"$t_{\mathrm{%s}} - t_{\mathrm{%s}}$ (s)" % (instrument1, instrument2)) axes.xaxis.grid(True, which="major,minor") axes.yaxis.grid(True, which="major,minor") return fig
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 df_plot(key, denominator_coords, denominator_data, numerator_coords, numerator_data): fig = figure.Figure(figsize=(4, 4 / golden_ratio)) FigureCanvas(fig) axes = fig.add_axes((.14, .15, .98 - .14, .90 - .15)) denominator_data = numpy.nan_to_num(denominator_data) numerator_data = numpy.nan_to_num(numerator_data) if numpy.any(denominator_data): axes.plot(denominator_coords, denominator_data, "k-", label="Background") if numpy.any(numerator_data): axes.plot(numerator_coords, numerator_data, "r-", label="Injections") ymin, ymax = axes.get_ylim() axes.set_ylim((max(ymin, ymax - 14), ymax)) axes.legend(loc="upper left") instrument1, instrument2 = key.split("-")[:2] axes.set_title(r"%s--%s Frequency Cutoff Asymmetry Distribution" % (instrument1, instrument2)) axes.set_ylabel(r"$\ln P$") axes.set_xlabel( r"$\left({f_{\mathrm{cut}}}_{\mathrm{%s}} - {f_{\mathrm{cut}}}_{\mathrm{%s}}\right) / \frac{1}{2} \left({f_{\mathrm{cut}}}_{\mathrm{%s}} + {f_{\mathrm{cut}}}_{\mathrm{%s}}\right)$" % (instrument1, instrument2, instrument1, instrument2)) axes.xaxis.grid(True, which="major,minor") axes.yaxis.grid(True, which="major,minor") return fig
def _make_ts_fig(): fig = figure.Figure(figsize=(9, 9)) ax1 = fig.add_subplot(2, 2, 1) ax2 = fig.add_subplot(2, 2, 2, sharex=ax1) ax3 = fig.add_subplot(2, 2, 3, sharex=ax1) ax4 = fig.add_subplot(2, 2, 4, sharex=ax1) return fig, [ax1, ax2, ax3, ax4]
def graphHeatMap(file_name, matrices, extents, names, axis_labels, title): '''current style only gens 2x2 heat maps! change length, width to make different kinds''' length = 2 width = 2 axes = [] fig = figure.Figure(figsize = (15, 15)) canvas = FigureCanvas(fig) fig.subplots_adjust(wspace = 0.45, hspace = 0.45) fig.suptitle(title) for matrix, extent, name, ind, axis_label in zip(matrices, extents, names, range(len(matrices)), axis_labels): # ax = plt.subplot2grid((width, length), (ind // 2, ind % 2)) ax = fig.add_subplot(width, length, ind + 1) ax.set_title(name, fontsize=24) ax.set_xlabel(axis_label[0], fontsize=24) ax.set_ylabel(axis_label[1], fontsize=24) img = ax.imshow(matrix, extent = extent, interpolation = 'none', vmin = np.nanmin(matrix), vmax = np.nanmax(matrix), cmap='bwr') ax.tick_params(axis='both', which='both', labelsize=18) fig.colorbar(img) pdf = PdfPages(file_name) pdf.savefig(fig) pdf.close()
def plot_setup(*args): # reduce scale of codeclimate complaints fig = figure.Figure() FigureCanvas(fig) ax = fig.gca() ax.grid(True) return fig, ax
def GetFigure(self, figsize=(6,6), dpi=75, facecolor="1.0", edgecolor="1.0", linewidth="1.0", frameon=True, subplotpars=None): fig = figure.Figure(figsize=figsize, dpi=dpi, facecolor=facecolor, edgecolor=edgecolor, linewidth=linewidth, frameon=frameon, subplotpars=subplotpars) backend_agg.FigureCanvasAgg(fig) return fig
def test_no_pyplot(): # tests pickle-ability of a figure not created with pyplot from matplotlib.backends.backend_pdf import FigureCanvasPdf fig = mfigure.Figure() _ = FigureCanvasPdf(fig) ax = fig.add_subplot(1, 1, 1) ax.plot([1, 2, 3], [1, 2, 3]) pickle.dump(fig, BytesIO(), pickle.HIGHEST_PROTOCOL)
def test_axes_object_with_ax(): fig = figure.Figure() ax = fig.add_subplot(1, 1, 1) fig1, ax1 = validate.axes_object(ax) assert isinstance(ax1, axes.Axes) assert isinstance(fig1, figure.Figure) assert ax1 is ax assert fig1 is fig
def test_unpickle_canvas(): fig = mfigure.Figure() assert fig.canvas is not None out = BytesIO() pickle.dump(fig, out) out.seek(0) fig2 = pickle.load(out) assert fig2.canvas is not None
def plot2d(orig: Tensor, recons: Tensor, model_name: str, epoch: int, out_path: str, rows: int, cols: int, display: str = 'horizontal', scaling: float = 1.0, dpi: int = 400, title: str = None, suptitle: dict = {}, img_filter: str = None, imshow_args: dict = {}): fig = figure.Figure(figsize=(cols * scaling, rows * scaling), dpi=dpi) grid = ImageGrid( fig, 111, # similar to subplot(111) nrows_ncols=(rows, cols), # creates 2x2 grid of axes axes_pad=0.1) # pad between axes in inch. i = 0 n = min(rows * cols, orig.shape[0]) to_pil = ToPILImage() displays = { 'horizontal': -1, 'vertical': -2, } dim = displays[display] for _ in range(rows): done = False for _ in range(cols): if i >= n: done = True break o = orig[i] r = recons[i] if img_filter is not None: o = run_img_filter(o, img_filter) r = run_img_filter(r, img_filter) img = torch.cat([o, r], dim=dim).byte() #img = img.numpy() #img = np.transpose(img, axes=(2, 0, 1)) #img = img.astype(np.byte) #img = Image.frombytes(img) img = to_pil(img) ax = grid[i] ax.axis('off') ax.imshow(img, **imshow_args) i += 1 if done: break if title is not None: interpolated = plot_title(title, model_name, epoch) fig.suptitle(interpolated, **suptitle) fig.tight_layout() fig.savefig(out_path + '.png', bbox_inches='tight') plt.close(fig) plt.close('all')
def plot_estimated_variogram(self, clims: Optional[Tuple[float, float]] = None): # Visualize estimated variogram function and display figure on screen nx, ny, nz = self._nonparest.variogram_map_values().shape dx, dy, dz = self._nonparest.grid_resolution() xmin = -int(nx / 2) xmax = -xmin ymin = -int(ny / 2) ymax = -ymin zmin = -int(nz / 2) zmax = -zmin xv = np.linspace(xmin, xmax, nx) yv = np.linspace(ymin, ymax, ny) zv = np.linspace(zmin, zmax, nz) xm, ym, zm = np.meshgrid(xv, yv, zv) z_plot = int(np.floor(nz * 0.5)) vfunc = AnisotropicVariogram( family=self._family, nug=self._nugget).get_variogram_function() indep_data = np.vstack((xm.ravel(), ym.ravel(), zm.ravel())) params = list(self._parameters.values()) if not np.any(np.isnan(params)): varest = vfunc(indep_data, *params) varest = np.reshape(varest, (ny, nx, nz)) else: varest = np.full(shape=(ny, nx, nz), fill_value=np.nan) fig = mpl_f.Figure() ax1, ax2 = fig.subplots(1, 2) # Setup axis 1 if clims is not None: img = ax1.imshow(varest[:, :, z_plot], extent=(dx * xmin, dx * xmax, dy * ymin, dy * ymax), vmin=clims[0], vmax=clims[1]) else: img = ax1.imshow(varest[:, :, z_plot], extent=(dx * xmin, dx * xmax, dy * ymin, dy * ymax)) ax1.set_xlabel("h_x") ax1.set_ylabel("h_y") ax1.set_title("Fitted variogram model") fig.colorbar(img, ax=ax1, orientation='horizontal') # Setup axis 2 sill = vfunc(np.full((3, 1), np.inf), *params) img2 = ax2.imshow(varest[:, :, z_plot] / sill, vmax=1.0, vmin=0.0, extent=(dx * xmin, dx * xmax, dy * ymin, dy * ymax)) ax2.set_xlabel("h_x") ax2.set_ylabel("h_y") ax2.set_title("Fitted variogram model (scaled)") fig.colorbar(img2, ax=ax2, orientation='horizontal') return fig
def _plot_images( image_dir: PurePath, orig: str, image_list: List, scores: bool = False, outfile: str = None, ) -> None: """ Plotting function for plot_duplicates() defined below. Args: image_dir: image directory where all files in duplicate_map are present. orig: filename for which duplicates are to be plotted. image_list: List of duplicate filenames, could also be with scores (filename, score). scores: Whether only filenames are present in the image_list or scores as well. outfile: Name of the file to save the plot. """ n_ims = len(image_list) ncols = 4 # fixed for a consistent layout nrows = int(np.ceil(n_ims / ncols)) + 1 fig = figure.Figure(figsize=(10, 14)) gs = gridspec.GridSpec(nrows=nrows, ncols=ncols) ax = plt.subplot( gs[0, 1:3]) # Always plot the original image in the middle of top row ax.imshow( cv2.cvtColor(cv2.imread(str(image_dir / orig), cv2.IMREAD_COLOR), cv2.COLOR_BGR2RGB)) ax.set_title('Original Image: {}'.format(orig)) ax.axis('off') for i in range(0, n_ims): row_num = (i // ncols) + 1 col_num = i % ncols ax = plt.subplot(gs[row_num, col_num]) if scores: ax.imshow( cv2.cvtColor( cv2.imread(str(image_dir / image_list[i][0]), cv2.IMREAD_COLOR), cv2.COLOR_BGR2RGB)) val = _formatter(image_list[i][1]) title = ' '.join([image_list[i][0], f'({val})']) else: ax.imshow( cv2.cvtColor( cv2.imread(str(image_dir / image_list[i]), cv2.IMREAD_COLOR), cv2.COLOR_BGR2RGB)) title = image_list[i] ax.set_title(title, fontsize=6) ax.axis('off') gs.tight_layout(fig) if outfile: plt.savefig(outfile) plt.show()
def showGraph(): """ Creates a window that shows a popularity graph. """ from booklist import monthly # Creating a window statsWin = Tk() statsWin.title("Book Popularity") statsWin.geometry("1024x768") statsWin.resizable(False, False) # Creating the graph graphFrame = Frame(statsWin) fig = plt.Figure(figsize=(10.24, 7.68), dpi=100, tight_layout=True) area = fig.add_subplot(111) statsWin.withdraw() # Hides window until done # translating options into respective values (days) optn = timeVar.get() tRange = { "Last Month": 30, "Last 3 Months": 90, "Last 6 Months": 180, "Last Year": 365, } # gets all transactions from log that is within selected time frame bookList = monthly(tRange[optn]) x = list(bookList.keys()) y = list(bookList.values()) if len(x) < 5 or len(y) < 5: messagebox.showwarning( "Feature Unavailable.", "This feature is not available as the log file is not populated enough." ) return # Embeds graph into Tk graph = FigureCanvasTkAgg(fig, graphFrame) # Plotting graph area.bar(x, y) area.set_xlabel("Book Titles") area.set_ylabel("Copies on loan") # rotates label 90 degrees for readability [label.set_rotation(90) for label in area.get_xticklabels()] graph.draw() graph.get_tk_widget().pack() graphFrame.pack() statsWin.deiconify() # show window statsWin.mainloop()
def makePortionFigure(deblend, origMimg, origMimgB, pedestal=0.0): portions = [] centers = [] boxes = [] for i, peak in enumerate(deblend.peaks): # make an image matching the size of the original portionedImg = afwImage.ImageF(origMimg.getBBox()) # get the heavy footprint for the flux aportioned to this peak heavyFoot = peak.getFluxPortion() footBox = heavyFoot.getBBox() pk = peak.peak centers.append((pk.getIx(), pk.getIy())) boxes.append(((footBox.getMinX(), footBox.getMinY()), footBox.getWidth(), footBox.getHeight())) print(i, peak, pk.getIx(), pk.getIy(), footBox, "skip:", peak.skip) # make a sub-image for this peak, and put the aportioned flux into it portionedSubImg = afwImage.ImageF(portionedImg, footBox) portionedSubImg += pedestal heavyFoot.insert(portionedSubImg) portions.append(portionedImg) fig = figure.Figure(figsize=(8, 10)) canvas = FigCanvas(fig) g = int(numpy.ceil(numpy.sqrt(len(deblend.peaks)))) gx, gy = g, g+1 def makeAx(ax, im, title): im = im.getArray() a = ax.imshow(im, cmap='gray') cb = fig.colorbar(a) ax.set_title(title, size='small') ax.set_xlim((0, im.shape[0])) ax.set_ylim((0, im.shape[1])) for t in ax.get_xticklabels() + ax.get_yticklabels() + cb.ax.get_yticklabels(): t.set_size('x-small') return ax # show the originals makeAx(fig.add_subplot(gy, gx, 1), origMimg.getImage(), "Orig") makeAx(fig.add_subplot(gy, gx, 2), origMimgB.getImage(), "Missing Src") # show each aportioned image i = gy for i_p in range(len(portions)): im = portions[i_p] ax = makeAx(fig.add_subplot(gy, gx, i), im, "") xy, w, h = boxes[i_p] ax.add_patch(Rectangle(xy, w, h, fill=False, edgecolor='#ff0000')) for x, y in centers: ax.plot(x, y, '+', color='#00ff00') i += 1 return fig
def __init__(self): self.fig = mpl_figure.Figure() self.ax = self.fig.add_subplot(111) mpl_backend_qt5agg.FigureCanvasQTAgg.__init__(self, self.fig) mpl_backend_qt5agg.FigureCanvasQTAgg.setSizePolicy( self, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding) mpl_backend_qt5agg.FigureCanvasQTAgg.updateGeometry(self)
def createThreeDFigure(self): self.figure = figure.Figure(dpi=80) figCanvas = FigureCanvas(self.figure) layout = QVBoxLayout(self) layout.addWidget(figCanvas) # 添加FigureCanvas对象 layout.setContentsMargins(0, 0, 0, 0) layout.setSpacing(0)
def __init__(self, name=None, figsize=(6, 4), position=(0.1, 0.1, 0.8, 0.8)): import matplotlib.backends.backend_tkagg as mpTkAgg import matplotlib.figure as mpfig import sys # Window widget self.window = Tk.Toplevel() if name is not None: assert type(name) is str self.window.title(name) self.name = self.window.title() def callback(): self.window.withdraw() self.window.bind("<Destroy>", callback) self.window.protocol("WM_DELETE_WINDOW", callback) button = Tk.Button(ROOT, text='Show %s window' % self.window.title(), command=self.window.deiconify) button.pack(side=Tk.TOP) button.pack(fill=Tk.BOTH, expand=1) # Instantiate figure and plot self.f = mpfig.Figure(figsize=figsize, dpi=100) self.ax = self.f.add_subplot(111) self.ax.set_position(position) # Instantiate canvas self.canvas = canvas = mpTkAgg.FigureCanvasTkAgg(self.f, self.window) # Pack canvas into window canvas.get_tk_widget().pack(side=Tk.TOP, fill=Tk.BOTH, expand=1) canvas._tkcanvas.pack(side=Tk.TOP, fill=Tk.BOTH, expand=1) # Instantiate and pack toolbar self.toolbar = toolbar = mpTkAgg.NavigationToolbar2TkAgg( canvas, self.window) # Instantiate and pack quit button #self.button = button = Tk.Button(self.window, text='Quit', command=sys.exit) #button.pack(side=Tk.BOTTOM) # Show canvas and toolbar toolbar.update() canvas.show() # Init nplots to zero self.nplots = 0 # Init names self.names = [] return
def __init__(self, width, height, dpi=96): # time increments, by minute self.time_inc_min = 15 # create matplotlib figure self.fig = figure.Figure(figsize=(width, height), dpi=dpi) # colors used for successive points self.colors = ['r', 'b', 'g', 'c', 'm', 'y']
def rain_clock(dataframe, raincol='precip'): """ Mathematically dubious representation of the likelihood of rain at at any hour given that will rain. Parameters ---------- dataframe : pandas.DataFrame raincol : string, optional (default = 'precip') The name of the column in *dataframe* that contains the rainfall series. Returns ------- fig : matplotlib.Figure """ if not hasattr(dataframe, raincol): raise ValueError('input `dataframe` must have a `%s` column' % raincol) rainfall = dataframe[raincol] am_hours = numpy.arange(0, 12) am_hours[0] = 12 rainhours = rainfall.index.hour rain_by_hour = [] for hr in numpy.arange(24): selector = (rainhours == hr) total_depth = rainfall[selector].sum() num_obervations = rainfall[selector].count() rain_by_hour.append(total_depth / num_obervations) bar_width = 2 * numpy.pi / 12 * 0.8 fig = figure.Figure(figsize=(7, 3)) ax1 = fig.add_subplot(1, 2, 1, polar=True) ax2 = fig.add_subplot(1, 2, 2, polar=True) theta = numpy.arange(0.0, 2 * numpy.pi, 2 * numpy.pi / 12) ax1.bar(theta + 2 * numpy.pi / 12 * 0.1, rain_by_hour[:12], bar_width, color='DodgerBlue', linewidth=0.5) ax2.bar(theta + 2 * numpy.pi / 12 * 0.1, rain_by_hour[12:], bar_width, color='Crimson', linewidth=0.5) ax1.set_title('AM Hours') ax2.set_title('PM Hours') for ax in [ax1, ax2]: ax.set_theta_zero_location("N") ax.set_theta_direction('clockwise') ax.set_xticks(theta) ax.set_xticklabels(am_hours) ax.set_yticklabels([]) return fig
def main(): args = parse_args() fixed_img = skio.imread(args.fixed_img, as_gray=True) fixed_annot = np.loadtxt(args.fixed_annot, delimiter=',', skiprows=1, dtype=np.int32) moved_img = skio.imread(args.moved_img, as_gray=True) moved_annot = np.loadtxt(args.moved_annot, delimiter=',', skiprows=1, dtype=np.int32) # load map data mapdata = get_map_from_h5(args.map, args.map_group) nodes_x, nodes_y = get_nodes_from_h5(args.map, args.map_group) # update csv points from interpolated map interp_x = si.RegularGridInterpolator((nodes_x, nodes_y), mapdata[0]) interp_y = si.RegularGridInterpolator((nodes_x, nodes_y), mapdata[1]) offsets_x = interp_x(fixed_annot[:, 1:]) offsets_y = interp_y(fixed_annot[:, 1:]) # Set figsize for 1:1 pixels figsize = (fixed_img.shape[1] / dpi, fixed_img.shape[0] / dpi) fig = mf.Figure(figsize=figsize) canvas = mplbea.FigureCanvasAgg(fig) ax = fig.add_axes((0, 0, 1, 1)) ax.set_axis_off() ax.imshow(fixed_img, cmap=cols1[0], aspect='auto') ax.imshow(moved_img, cmap=cols2[0], alpha=0.5, aspect='auto') ax.plot(fixed_annot[:, 1], fixed_annot[:, 2], color=cols1[1], marker='.', linestyle="none", markersize="1") ax.plot(moved_annot[:, 1], moved_annot[:, 2], color=cols2[1], marker='.', linestyle="none", markersize="1") ax.quiver(fixed_annot[:, 1], fixed_annot[:, 2], offsets_x, offsets_y, angles='xy', scale_units='xy', scale=1) fig.savefig(args.output, dpi=dpi)
def plot_spectrogram(self): f = fig.Figure() f.add_subplot(111).specgram(self.wav_data, NFFT=1024, noverlap=900, Fs=self.sr) canvas = FigureCanvasTkAgg(f, master=self) canvas.draw() canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)
def coordPlot(exposure, finder, pngfile): mm = finder._mm cmm = finder._mmCals img = exposure.getMaskedImage().getImage().getArray() bins = 1.0*img.shape[1]/mm.img.shape[1] xx, yy = np.meshgrid(np.arange(mm.img.shape[1], dtype=int), np.arange(mm.img.shape[0], dtype=int)) x = (bins*xx[finder._isCandidate]).astype(int) y = (bins*yy[finder._isCandidate]).astype(int) cimg = np.zeros(img.shape) cimg[y,x] = 1.0 def small(ax): for t in ax.get_xticklabels() + ax.get_yticklabels(): t.set_size("small") fig = figure.Figure(figsize=(8.0,4.0)) fig.subplots_adjust(bottom=0.15) can = FigCanvas(fig) ax = fig.add_subplot(1, 3, 1) ax.imshow(np.arcsinh(img), origin='lower', cmap='gray') ax.set_xlim([0, img.shape[1]]) ax.set_ylim([0, img.shape[0]]) small(ax) ax = fig.add_subplot(1, 3, 3) stride = 1 #ax.plot(mm.theta[::stride], mm.ellip[::stride], '.k', ms=0.2, alpha=0.2) ax.scatter(mm.theta[::stride], mm.ellip[::stride], c=np.clip(mm.center[::stride], 0.0, 4.0*finder.centerLimit), s=0.2, alpha=0.2, edgecolor='none') if len(cmm) == 2: i = 0 else: i = 2 ax.hlines([cmm[i].ellip], -np.pi/2.0, np.pi/2.0, color='k', linestyle='-') ax.set_xlim([-np.pi/2.0, np.pi/2.0]) ax.set_ylim([0.0, 1.0]) ax.set_xlabel("$\\theta$") ax.set_ylabel("$e=1-B/A$") ax.yaxis.set_label_position("right") ax.yaxis.tick_right() small(ax) ax = fig.add_subplot(1, 3, 2) ax.imshow(cimg, origin='lower', cmap='gray_r') ax.plot(x, y, 'k.', ms=1.0) ax.set_xlim([0, img.shape[1]]) ax.set_ylim([0, img.shape[0]]) small(ax) fig.savefig(pngfile) fig.savefig(re.sub("png", "eps", pngfile))
def __init__(self, name="holder occupation"): """Create a new instance of this graph""" self.name = name self.__fig = figure.Figure() self.__fig.hold(False) self.plot = self.__fig.add_subplot(111) self.lines = [] self.labels = [] self.legend = dict() self.max = 0
def __init__(self, name=_("product life-cycle"), limit=50): """Create a new instance of a ProductChart""" self.name = name self.limit = limit self.__fig = figure.Figure() self.plot = self.__fig.add_subplot(111) self.rows = [] self.legend = dict() self.colormap = cm.ScalarMappable(cmap=cm.gist_rainbow) self.colormap.set_clim(0, 1)
def __init__(self): self._fig: figure.Figure = figure.Figure(frameon=False, dpi=100.0) self._figure_canvas: backend_qt5agg.FigureCanvasQTAgg = backend_qt5agg.FigureCanvasQTAgg(self._fig) # Space around axes. Documentation not helpful. Taken from stack-overflow. self._fig.subplots_adjust(top=1, bottom=0, right=1, left=0, hspace=0, wspace=0) self._ax: figure.Axes = self._fig.subplots() self._drawable: Optional[drawable.Drawable] = None self._buf: Optional[memoryview] = None self._rgba_output: Optional[np.ndarray] = None self._current_shape: Optional[tuples.ImageShape] = None