def _plot_warning_message(ax: plt.Axes, label: str, keys: List[str]) -> None: text = "Unable to plot {}.\nRelevant information not available in history object.\nNeed history keys: {}".format( label, ", ".join(keys)) ax.text(0.5, 0.5, text, ha="center", va="center") ax.set_xlim(0, 1) ax.set_ylim(0, 1) ax.axis("off")
def __init__(self, ax: plt.Axes = None, set_ax=False, img_path: str = None, **kwargs): """ Renders an image of the hairpin maze on a matplotlib axis """ ax = ax or plt.gca() image = self.get_image(img_path) ax.imshow( image, extent=[self.x_0, self.x_1, self.y_0, self.y_1], origin="lower", zorder=-100, **kwargs, ) if set_ax: ax.set( xlim=[self.x_0, self.x_1], ylim=[self.y_0, self.y_1], xlabel="cm", ylabel="cm", xticks=[self.x_0, self.x_1], yticks=[self.y_0, self.y_1], ) clean_axes(ax.figure) ax.axis("equal")
def show_image(img:PIL.Image, ax:plt.Axes=None, figsize:tuple=(3,3), hide_axis:bool=True, cmap:str='binary', alpha:float=None, **kwargs)->plt.Axes: "Display `Image` in notebook." if ax is None: fig,ax = plt.subplots(figsize=figsize) ax.imshow(pil2np(img), cmap=cmap, alpha=alpha, **kwargs) if hide_axis: ax.axis('off') return ax
def show_image(img: NiiImage, ax: plt.Axes = None, figsize: tuple = (3, 3), hide_axis: bool = True, cmap: str = 'gray', cmap_y: str = 'jet', alpha: float = 0.5, y=None, anatomical_plane: str = None, title: str = None, **kwargs) -> plt.Axes: "Display `Image` in notebook." if ax is None: fig, ax = plt.subplots(figsize=figsize) show_slice_img(img=img, ax=ax, cmap=cmap, anatomical_plane=anatomical_plane, title=title, **kwargs) if y is not None: show_slice_img(img=y, ax=ax, cmap=cmap_y, alpha=alpha, anatomical_plane=anatomical_plane, title=title, **kwargs) #TODO change cmap if hide_axis: ax.axis('off') return ax
def manual_auto_scatter(manual, auto, title=None, ax: plt.Axes = None): if not ax: _, ax = plt.subplots() if title: ax.set_title(title) ax.set_xlabel("manual") ax.set_ylabel("auto") ax.axis("equal") ax.scatter(manual, auto) coeffs, residuals, rank, singular_values, rcond = np.polyfit(manual, auto, 1, full=True) x = np.unique(manual) y = np.poly1d(coeffs)(x) f = np.poly1d(coeffs)(manual) ss_tot = np.sum((np.array(auto) - np.mean(y))**2) ss_res = np.sum((np.array(auto) - f)**2) r2 = 1 - (ss_res / ss_tot) ax.plot( x, y, label=r"linear best fit \newline $y = ({})x {}$ \newline $R^2 = {:.3f}$" .format(latex_float(coeffs[0]), ensure_sign(latex_float(coeffs[1])), r2), ) ax.legend()
def __setup_subplot__(self, rhythm_loop: RhythmLoop, axes: plt.Axes, **kw): box_notation_grid_info = plot_box_notation_grid( axes, rhythm_loop, self.unit, self.position, self.text_box_width, self.line_width, self.line_color) container = box_notation_grid_info['container'] # type: Rectangle2D # get viewport dimensions x_padding = (self.rel_pad_x * box_notation_grid_info['container'].width) / 2 x_bounds = [ container.x_bounds[0] - x_padding, container.x_bounds[1] + x_padding ] y_padding = (abs(x_bounds[0] - x_bounds[1]) - container.height) / 2 y_bounds = [ container.y_bounds[0] - y_padding, container.y_bounds[1] + y_padding ] # setup viewport axes.axis("equal") # equal axis for perfectly "squared" squares.. :) axes.set_xlim(*x_bounds) axes.set_ylim(*reversed( y_bounds)) # reversed to have (0, 0) in upper-left position return { **box_notation_grid_info, 'viewport': Rectangle2D(x=x_bounds[0], y=y_bounds[0], width=abs(x_bounds[0] - x_bounds[1]), height=abs(y_bounds[0] - y_bounds[1])) }
def plot_analyzed_subimage(self, subimage: str='wobble', ax: plt.Axes=None, show: bool=True): """Plot a subimage of the starshot analysis. Current options are the zoomed out image and the zoomed in image. Parameters ---------- subimage : str If 'wobble', will show a zoomed in plot of the wobble circle. Any other string will show the zoomed out plot. ax : None, matplotlib Axes If None (default), will create a new figure to plot on, otherwise plot to the passed axes. """ if ax is None: fig, ax = plt.subplots() # show analyzed image ax.imshow(self.image.array, cmap=get_dicom_cmap()) self.lines.plot(ax) self.wobble.plot2axes(ax, edgecolor='green') self.circle_profile.plot2axes(ax, edgecolor='green') ax.autoscale(tight=True) ax.axis('off') # zoom in if wobble plot if subimage == 'wobble': xlims = [self.wobble.center.x + self.wobble.diameter, self.wobble.center.x - self.wobble.diameter] ylims = [self.wobble.center.y + self.wobble.diameter, self.wobble.center.y - self.wobble.diameter] ax.set_xlim(xlims) ax.set_ylim(ylims) ax.axis('on') if show: plt.show()
def imshow(img: np.ndarray, axis: str = 'on', ax: plt.Axes = None, add_colorbar: bool = True, **kwargs) -> (plt.Figure, plt.Axes): """Imshow wrapper to plot images in various image spaces. Constructs a figure object under the hood. Arguments --------- img: the input image axis: whether to display the axis with ticks and everything by default ax: if None, create new plt Axes, otherwise take this one for plotting kwargs: those will be forwarded into the setup_plt_figure function Returns ------- fig, ax: a tuple of a matplotlib Figure and Axes object """ if ax is None: fig, ax = setup_plt_figure(**kwargs) else: fig = ax.get_figure() ax.set_title(kwargs.get('title', '')) ax.axis(axis) imshow_kwargs = {'cmap': kwargs['cmap'] if 'cmap' in kwargs else 'hot'} for key in ['vmin', 'vmax']: if key in kwargs: imshow_kwargs[key] = kwargs.get(key) im = ax.imshow(img, **imshow_kwargs) if add_colorbar: divider = make_axes_locatable(ax) cax = divider.append_axes("right", size="2%", pad=0.05) plt.colorbar(im, cax=cax) font = {'family': 'normal', 'weight': 'bold', 'size': 12} matplotlib.rc('font', **font) return fig, ax
def show_image(img: Image, ax: plt.Axes = None, figsize: tuple = (3, 3), hide_axis: bool = True) -> plt.Axes: """Show image using Matplotlib Parameters ---------- img Image object ax Axes to use for showing image (default = None, will be created) figsize Figure size to use (default = (3, 3)) hide_axis Flag to decide to show axis or not (default = True, hide it) Returns ------- Axes with plotted image """ if ax is None: fig, ax = plt.subplots(figsize=figsize) ax.imshow(img.data) if hide_axis: ax.axis('off') return ax
def show_image(img:Tensor, ax:plt.Axes=None, figsize:tuple=(3,3), hide_axis:bool=True, title:Optional[str]=None, cmap:str='binary', alpha:Optional[float]=None)->plt.Axes: "plot tensor `img` using matplotlib axis `ax`. `figsize`,`axis`,`title`,`cmap` and `alpha` pass to `ax.imshow`" if ax is None: fig,ax = plt.subplots(figsize=figsize) ax.imshow(image2np(img), cmap=cmap, alpha=alpha) if hide_axis: ax.axis('off') if title: ax.set_title(title) return ax
def plot_table_from_df(df: pd.DataFrame, colors: List[str], axis: plt.Axes): """Plot table from dataframe in mmatplotlib axis.""" cell_text = [] for row in range(len(df)): cell_text.append(df.iloc[row]) cell_colors = [colors for _ in range(len(df.columns))] head_colors = ["#FF0000" for _ in range(len(df.columns))] axis.table(cellText=cell_text, colLabels=df.columns, cellColours=cell_colors, colColours=head_colors, loc='center') axis.axis('off')
def draw_segmentation( img: np.ndarray, mask: np.ndarray, idx_name_dict: Dict[int, str], colors: List = None, title: str = '', ax: plt.Axes = None, figsize: Tuple[int, int] = (16, 8), ): if colors is None: colors = generate_colormap(len(idx_name_dict) + 1) if ax is None: _, ax = plt.subplots(figsize=figsize) width, height = img.size ax.set_ylim(height + 10, -10) ax.set_xlim(-10, width + 10) ax.axis('off') ax.set_title(title) out_image = np.array(img).astype(np.uint8) for cat in np.unique(mask)[1:]: mask_cat = (mask == cat) cat_name = idx_name_dict[cat] color = colors[cat] # draw text in the center (defined by median) when box is not drawn # median is less sensitive to outliers. text_pos = np.median(mask_cat.nonzero(), axis=1)[::-1] - 20 # horiz_align = "left" lighter_color = change_color_brightness(color, brightness_factor=0.7) font_size = 10 draw_text(ax, cat_name, text_pos, font_size, horizontal_alignment='left') padded_mask = np.zeros((mask_cat.shape[0] + 2, mask_cat.shape[1] + 2), dtype=np.uint8) padded_mask[1:-1, 1:-1] = mask_cat contours = measure.find_contours(padded_mask, 0.5) for verts in contours: verts = np.fliplr(verts) - 1 p = Polygon( verts, facecolor=color, edgecolor=lighter_color, # 'black', fill=True, alpha=.5) ax.add_patch(p) ax.imshow(out_image) return ax
def show_image(img, ax: plt.Axes = None, figsize: tuple = (3, 3), hide_axis: bool = True, cmap: str = 'viridis', alpha: float = None, **kwargs) -> plt.Axes: """Display `Image` in notebook.""" if ax is None: fig, ax = plt.subplots(figsize=figsize) xtr = dict(cmap=cmap, alpha=alpha, **kwargs) ax.imshow(image2np(img.data), **xtr) if (hasattr(img, 'data')) else ax.imshow(img, **xtr) if hide_axis: ax.axis('off') return ax
def measureTau(abf: pyabf.ABF, sweep: int, epoch: int = 3, percentile: float = .05, ax: plt.Axes = None): abf.setSweep(sweep) # use epoch table to determine puff times puffTimeStart = abf.sweepEpochs.p1s[epoch] / abf.sampleRate puffTimeEnd = abf.sweepEpochs.p2s[epoch] / abf.sampleRate # calculate baseline level baselineStart = puffTimeStart - .1 baselineEnd = puffTimeStart baselineMean = getMean(abf, baselineStart, baselineEnd) # find antipeak antipeakIndex = getAntiPeakIndex(abf.sweepY, abf.sampleRate, puffTimeStart, puffTimeStart + .5) antipeakLevel = abf.sweepY[antipeakIndex] # find portion of curve to fit curveIndex1, curveIndex2 = getCurveIndexes(abf.sweepY, antipeakIndex, baselineMean, percentile) curveYs = -abf.sweepY[curveIndex1:curveIndex2] curveXs = np.arange(len(curveYs)) / abf.sampleRate try: p0 = (500, 15, 0) # start with values near those we expect params, cv = scipy.optimize.curve_fit(monoExp, curveXs, curveYs, p0) except: print(f"FIT FAILED (sweep {sweep})") return None m, t, b = params curveYsIdeal = monoExp(curveXs, m, t, b) tauMS = 1000 / t if (tauMS < 0): return None if ax: yPad = abs(antipeakLevel - baselineMean) * .1 ax.plot(abf.sweepX, abf.sweepY, alpha=.5) ax.grid(alpha=.5, ls='--') ax.axhline(baselineMean, ls='--', color='k') ax.plot(abf.sweepX[curveIndex1:curveIndex2], -curveYsIdeal, color='k') ax.set(title=f"first sweep tau = {tauMS:.02f} ms") ax.axis([ baselineStart - .1, baselineStart + 1, antipeakLevel - yPad, baselineMean + yPad ]) ax.axvspan(puffTimeEnd, puffTimeEnd + .5, color='g', alpha=.1) ax.axvspan(puffTimeEnd + .5, puffTimeEnd + .6, color='m', alpha=.1) return tauMS
def plot_text(axes: plt.Axes, text: str): """Plot text on an axes Args: axes (plt.Axes): an axes object text (str): the text """ axes.axis('off') axes.grid('off') axes.text(x=0, y=0, s=text, horizontalalignment='left', fontdict=FONT)
def make_plot( self, axes: pyplot.Axes = None, vmin: float = None, vmax: float = None, show: bool = False, title: str = None, # figsize=rcParams["figure.figsize"], extent: (float, float, float, float) = None, cbar_label: str = None, **kwargs ): if vmin is None: vmin = np.min(self.values) if vmax is None: vmax = np.max(self.values) kwargs.update(**fig.get_topobathy_kwargs(self.values, vmin, vmax)) kwargs.pop('col_val') levels = kwargs.pop('levels') if vmin != vmax: self.tricontourf( axes=axes, levels=levels, vmin=vmin, vmax=vmax, **kwargs ) else: self.tripcolor(axes=axes, **kwargs) self.quadface(axes=axes, **kwargs) axes.axis('scaled') if extent is not None: axes.axis(extent) if title is not None: axes.set_title(title) mappable = ScalarMappable(cmap=kwargs['cmap']) mappable.set_array([]) mappable.set_clim(vmin, vmax) divider = make_axes_locatable(axes) cax = divider.append_axes("bottom", size="2%", pad=0.5) cbar = plt.colorbar( mappable, cax=cax, orientation='horizontal' ) cbar.set_ticks([vmin, vmax]) cbar.set_ticklabels([np.around(vmin, 2), np.around(vmax, 2)]) if cbar_label is not None: cbar.set_label(cbar_label) if show: pyplot.show() return axes
def show(self, ax: plt.Axes = None, figsize: tuple = (3, 3), title: Optional[str] = None, hide_axis: bool = True, annotate=False, plot_lines=True, colors='r', **kwargs): if ax is None: _, ax = plt.subplots(figsize=figsize) data = self.data pnt = data[:, :2] visible = data[:, 2] pnt = scale_flow(FlowField(self.size, pnt), to_unit=False).flow.flip(1) lip_utils.plot_joint(ax, pnt, visible, annotate=annotate, plot_lines=plot_lines, colors=colors) if hide_axis: ax.axis('off') if title: ax.set_title(title)
def plot_mpl(self, ax: plt.Axes = None, key: str = None, **kwargs) -> plt.Axes: """Simple mesh plot using `matplotlib`. Parameters ---------- ax : plt.Axes, optional Axes to use for plotting. key : str, optional Label of cell data item to plot, defaults to the first key in `.cell_data`. fields : dict Maps cell data value to string for legend. **kwargs Extra keyword arguments passed to `ax.triplot` Returns ------- plt.Axes """ if not ax: fig, ax = plt.subplots() if key is None: try: key = tuple(self.cell_data.keys())[0] except IndexError: pass # https://github.com/python/mypy/issues/9430 cell_data = self.cell_data.get(key, self.zero_labels) # type: ignore for cell_data_val in np.unique(cell_data): vert_x, vert_y = self.points.T name = self.number_to_field.get(cell_data_val, cell_data_val) ax.triplot(vert_y, vert_x, triangles=self.cells, mask=cell_data != cell_data_val, label=name) ax.set_title(f'{self._cell_type} mesh') ax.axis('equal') _legend_with_triplot_fix(ax, title=key) return ax
def plot2d( mesh: BaseMesh, *, metric: str, ax: plt.Axes = None, **kwargs, ) -> plt.Axes: """Create a mesh plot with the cells are colored by the cell quality. Parameters ---------- mesh : BaseMesh Input mesh metric : str Metric to calculate. ax : `matplotlib.Axes` If specified, `ax` will be used to create the subplot. vmin, vmax : int, float Set the lower/upper boundary for the color value. Defaults to the 1st and 99th percentile, respectively. cmap : str Set the color map. **kwargs Keyword arguments passed on to `ax.tripcolor`. Returns ------- ax : `matplotlib.Axes` """ descriptor = _metric_dispatch[metric] quality = descriptor.func(mesh) # type: ignore kwargs.setdefault('vmin', np.percentile(quality, 1)) kwargs.setdefault('vmax', np.percentile(quality, 99)) fig, ax = plt.subplots() x = mesh.points[:, 0] y = mesh.points[:, 1] cells = mesh.cells tpc = ax.tripcolor(x, y, quality, triangles=cells, **kwargs) ax.figure.colorbar(tpc) ax.axis('scaled') ax.set_title(f'Triplot of {descriptor.name.lower()}') return ax
def plot_2G(ax: plt.Axes): # data from analysis.analyze_shuffling.ipynb import pickle with open('../data/shuffled.dat', 'rb') as f: x = pickle.load(f) y = pickle.load(f) plt.scatter(x, y, fc='gray', ec='k', linewidths=0.5, s=5, alpha=0.5) xy_min, xy_max = min(min(x), min(y)), max(max(x), max(y)) plt.plot([xy_min, xy_max], [xy_min, xy_max], ':', color='gray') ax.axis('equal') ax.set_xlabel(r'$\mathcal{L}$(human choices)') ax.set_ylabel(r'$\mathcal{L}$(shuffled choices)') plt.yticks([-200, -150], rotation=90, va='center') ax.spines['right'].set_visible(False) ax.spines['top'].set_visible(False) plt.tight_layout()
def __setup_subplot__(self, rhythm_loop: RhythmLoop, axes: plt.Axes, **kw): # avoid stretching the aspect ratio axes.axis('equal') # noinspection PyTypeChecker axes.axis([0, 1, 0, 1]) # add base rhythm circle main_radius = 0.3 main_center = 0.5, 0.5 # draws a wedge from the given start pulse to the given end pulse def draw_wedge(pulse_start, pulse_end, center=main_center, radius=main_radius, **kw_): theta_1, theta_2 = (((90 - (pulse / n_pulses * 360)) % 360) for pulse in (pulse_end, pulse_start)) axes.add_artist(Wedge(center, radius, theta_1, theta_2, **kw_)) unit = self.get_unit() n_pulses = kw['n_pulses'] n_pulses_per_measure = int(rhythm_loop.get_measure_duration(unit)) try: n_measures = int(n_pulses / n_pulses_per_measure) except ZeroDivisionError: n_measures = 0 # measure wedges for i_measure in range(0, n_measures, 2): from_pulse = i_measure * n_pulses_per_measure to_pulse = (i_measure + 1) * n_pulses_per_measure draw_wedge(from_pulse, to_pulse, radius=1.0, fc=to_rgba("gray", 0.25)) # main circle circle = plt.Circle(main_center, main_radius, fc="white") axes.add_artist(circle) # draw the pulse wedges for i_pulse in range(0, n_pulses, 2): draw_wedge(i_pulse, i_pulse + 1, fc=to_rgba("gray", 0.25)) return circle
def plot(self, ax: plt.Axes = None) -> None: for key in self.keys: if self._odict[key] is None: continue elif key == 'roc_curve': fpr, tpr, thresholds = self._odict[key] if ax is None: fig = plt.figure(figsize=(6, 6)) ax = plt.subplot(1, 1, 1) ax.plot(fpr, tpr) ax.set_title("ROC Curve") ax.set_xlabel("False Positive Rate") ax.set_ylabel("True Positive Rate") ax.axis('equal') if ax is None: plt.show()
def info( data: SWIFTDataset, ax: plt.Axes, radial_bins: np.array, center: np.array ) -> None: metadata = data.metadata try: viscosity = metadata.viscosity_info except: viscosity = "No info" try: diffusion = metadata.diffusion_info except: diffusion = "No info" output = ( "$\\bf{SWIFT}$\n" + metadata.code_info + "\n\n" + "$\\bf{Compiler}$\n" + metadata.compiler_info + "\n\n" + "$\\bf{Hydrodynamics}$\n" + metadata.hydro_info + "\n\n" + "$\\bf{Viscosity}$\n" + viscosity + "\n\n" + "$\\bf{Diffusion}$\n" + diffusion ) ax.text( 0.5, 0.45, output, ha="center", va="center", fontsize=info_fontsize, transform=ax.transAxes, ) ax.axis("off")
def scatter_pred_vs_tag(y_hat, y_gt, title, ax:plt.Axes=None, save_path="plots/new scatter pred tag"): """ plot scatter of predict vs real tag @param y_hat: predict @param y_gt: real tag @param title: plot title @param save_path: where to save plot @return: """ if ax is None: fig, ax = plt.subplots(1) ax.scatter(y_hat, y_gt) ax.set_title("predict vs real tag " + title) ax.set_xlabel("predict") ax.set_ylabel("real tag") ax.axis('square') if ax is None: fig.savefig(f"{save_path}/new scatter pred vs tag " + title + ".svg") plt.show(fig)
def hexplot( ax: plt.Axes, grid: np.ndarray, data: np.ndarray, hex_size: float=11.5, cmap: str='viridis' ) -> plt.Axes: ''' Plot grid and data on a hexagon grid. Useful for SOMs. Parameters ---------- ax : Axes to plot on. grid : Array of (x, y) tuples. data : Array of len(grid) with datapoint. hex_size : Radius in points determining the hexagon size. cmap : Colormap to use for colouring. Returns ------- ax : Axes with hexagon plot. ''' # Create hexagons collection = RegularPolyCollection( numsides=6, sizes=(2 * np.pi * hex_size ** 2,), edgecolors=(0, 0, 0, 0), transOffset=ax.transData, offsets=grid, array=data, cmap=plt.get_cmap(cmap) ) # Scale the plot properly ax.add_collection(collection, autolim=True) ax.set_xlim(grid[:, 0].min() - 0.75, grid[:, 0].max() + 0.75) ax.set_ylim(grid[:, 1].min() - 0.75, grid[:, 1].max() + 0.75) ax.axis('off') return ax
def hexplot( ax: plt.Axes, grid: np.ndarray, data: np.ndarray, hex_size: float=11.5, cmap: str='viridis' ) -> plt.Axes: """ Plot grid and data on a hexagon grid. Useful for SOMs. Parameters ---------- ax : Axes to plot on. grid : Array of (x, y) tuples. data : Array of len(grid) with datapoint. hex_size : Radius in points determining the hexagon size. cmap : Colormap to use for colouring. Returns ------- ax : Axes with hexagon plot. """ # Create hexagons collection = RegularPolyCollection( numsides=6, sizes=(2 * np.pi * hex_size ** 2,), edgecolors=(0, 0, 0, 0), transOffset=ax.transData, offsets=grid, array=data, cmap=plt.get_cmap(cmap) ) # Scale the plot properly ax.add_collection(collection, autolim=True) ax.set_xlim(grid[:, 0].min() - 0.75, grid[:, 0].max() + 0.75) ax.set_ylim(grid[:, 1].min() - 0.75, grid[:, 1].max() + 0.75) ax.axis('off') return ax
def plot_board(ax_board: plt.Axes, board: Board, nums: IntPair, num_offsets: IntPair, index: int): ax_board.clear() ax_board.set_title(str(index)) for num, offset, top_y in zip(nums, num_offsets, PlotConst.col_top_y): # for loop by raw col_top_x = np.linspace(0, 1, num + 2)[1:-1] for cc in range(num): # flor loop by column column = board.get_board()[cc + offset] for ee in range(Column.LEN): ax_board.plot([col_top_x[cc]], [top_y - ee * PlotConst.y_pitch], color=column[ee].to_color_string(), **PlotConst.plot_args) ax_board.set_xlim([0, 1.1]) ax_board.set_ylim([0, 1.1]) ax_board.axis("off")
def imshow(img: np.ndarray, title: str = None, color: bool = True, cmap: str = "gray", axis: bool = False, ax: plt.Axes = None): if not ax: ax = plt # Plot Image if color: ax.imshow(img) else: ax.imshow(img, cmap=cmap) # Ask about the axis if not axis: ax.axis("off") # Ask about the title if title: ax.title(title)
def plot_analyzed_subimage(self, subimage: str = 'wobble', ax: plt.Axes = None, show: bool = True): """Plot a subimage of the starshot analysis. Current options are the zoomed out image and the zoomed in image. Parameters ---------- subimage : str If 'wobble', will show a zoomed in plot of the wobble circle. Any other string will show the zoomed out plot. ax : None, matplotlib Axes If None (default), will create a new figure to plot on, otherwise plot to the passed axes. """ if ax is None: fig, ax = plt.subplots() # show analyzed image ax.imshow(self.image.array, cmap=get_dicom_cmap()) self.lines.plot(ax) self.wobble.plot2axes(ax, edgecolor='green') self.circle_profile.plot2axes(ax, edgecolor='green') ax.autoscale(tight=True) ax.axis('off') # zoom in if wobble plot if subimage == 'wobble': xlims = [ self.wobble.center.x + self.wobble.diameter, self.wobble.center.x - self.wobble.diameter ] ylims = [ self.wobble.center.y + self.wobble.diameter, self.wobble.center.y - self.wobble.diameter ] ax.set_xlim(xlims) ax.set_ylim(ylims) ax.axis('on') if show: plt.show()
def draw_gridlike(graph: nx.Graph, ax: plt.Axes = None, tilted: bool = True, **kwargs) -> Dict[Any, Tuple[int, int]]: """Draw a grid-like graph using Matplotlib. This wraps nx.draw_networkx to produce a matplotlib drawing of the graph. Nodes should be two-dimensional gridlike objects. Args: graph: A NetworkX graph whose nodes are (row, column) coordinates or cirq.GridQubits. ax: Optional matplotlib axis to use for drawing. tilted: If True, directly position as (row, column); otherwise, rotate 45 degrees to accommodate google-style diagonal grids. **kwargs: Additional arguments to pass to `nx.draw_networkx`. Returns: A positions dictionary mapping nodes to (x, y) coordinates suitable for future calls to NetworkX plotting functionality. """ if ax is None: ax = plt.gca() # coverage: ignore if tilted: pos = { node: (y, -x) for node, (x, y) in _node_and_coordinates(graph.nodes) } else: pos = { node: (x + y, y - x) for node, (x, y) in _node_and_coordinates(graph.nodes) } nx.draw_networkx(graph, pos=pos, ax=ax, **kwargs) ax.axis('equal') return pos
def __init__(self, ax: plt.Axes, attitude_data: SO3): if not isinstance(ax, plt.Axes): raise TypeError("The axes must be of plt.Axes type.") if not isinstance(attitude_data, SO3): raise TypeError("The attitude_data must be an SO3 element.") # Background ah_circle = Circle((0, 0), radius=1.0, color='w', ec='w') ah_colouring = Circle((0, 0), radius=5.0, color='k') ax.add_patch(ah_colouring) ax.add_patch(ah_circle) # Horizon line self._attitude_data = attitude_data true_horizon = self._compute_horizon(attitude_data) self._horizon_line, = ax.plot(true_horizon[0, :], true_horizon[1, :]) # Horizon shading height = self._compute_horizon_height(attitude_data) slope = self._compute_horizon_slope(attitude_data) * 180.0 / np.pi self._shade = Wedge((0, height), 2.0, -180 + slope, slope, alpha=0.5) ax.add_patch(self._shade) # Clip path clip_circle = Circle((0, 0), radius=1.0, transform=ax.transData) self._horizon_line.set_clip_path(clip_circle) self._shade.set_clip_path(clip_circle) # Center Overlay ax.add_patch(Arc((0, 0), 0.3, 0.3, theta1=180, lw=2.0)) ax.plot([0.15, 0.6], [0, 0], color='k', lw=2.0) ax.plot([-0.15, -0.6], [0, 0], color='k', lw=2.0) # Axes settings ax.axis('square') ax.set_xlim([-1, 1]) ax.set_ylim([-1, 1])
def show_contour(self, ax: plt.Axes = None): """Plot contours on image. Parameters ---------- ax : matplotlib.Axes Axes to use for plotting. Returns ------- ax : matplotlib.Axes """ if not ax: fig, ax = plt.subplots() ax.set_title('Contours') self.contour.plot_mpl(ax=ax) ax.imshow(self.image) ax.axis('image') ax.set_xticks([]) ax.set_yticks([]) return ax