def opyfQuiverFieldColoredScaled(grid_x, grid_y, gridVx, gridVy, fig=None, ax=None, res=32, **args): fig, ax = getax(fig=fig, ax=ax) import opyf from matplotlib.colors import Normalize if 'cmap' not in args: args['cmap'] = mpl.cm.coolwarm cmap = args.get('cmap', mpl.cm.coolwarm) del args['cmap'] # one over N # Select randomly N vectors l, c = grid_x.shape resx = np.absolute(grid_x[0, 1]-grid_x[0, 0]) resy = np.absolute(grid_y[1, 0]-grid_y[0, 0]) densx = int(np.round(res/resx)) densy = int(np.round(res/resy)) lvec = np.arange(densy/2, l-densy/2, densy, dtype=int)+(l % densy)//2 cvec = np.arange(densx/2, c-densx/2, densx, dtype=int)+(l % densx)//2 new_grid_x = np.zeros(len(lvec)) size = (len(lvec), len(cvec)) temp_grid_x = grid_x[lvec, :] new_grid_x = temp_grid_x[:, cvec] temp_grid_y = grid_y[lvec, :] new_grid_y = temp_grid_y[:, cvec] new_gridVx = np.zeros(size) new_gridVy = np.zeros(size) for i in range(size[0]): for j in range(size[1]): new_gridVx[i, j] = np.mean( gridVx[lvec[i]-densy//2:lvec[i]+densy//2+1, cvec[j]-densx//2:cvec[j]+densx//2+1]) new_gridVy[i, j] = np.mean( gridVy[lvec[i]-densy//2:lvec[i]+densy//2+1, cvec[j]-densx//2:cvec[j]+densx//2+1]) TargetPoints = opyf.Interpolate.npGrid2TargetPoint2D( new_grid_x, new_grid_y) Velocities = opyf.Interpolate.npGrid2TargetPoint2D(new_gridVx, new_gridVy) Norme = (Velocities[:, 0]**2+Velocities[:, 1]**2)**0.5 if 'vlim' in args: vlim = args.get('vlim', [Norme.min(), Norme.max()]) if vlim is None: vlim = [Norme.min(), Norme.max()] del args['vlim'] else: vlim = [Norme.min(), Norme.max()] norm = Normalize() norm.autoscale(Norme) norm.vmin = vlim[0] norm.vmax = vlim[1] sm = mpl.cm.ScalarMappable(cmap=cmap, norm=norm) sm.set_array([]) qv = ax.quiver(TargetPoints[:, 0], TargetPoints[:, 1], Velocities[:, 0] / Norme[:], Velocities[:, 1]/Norme[:], color=cmap(norm(colors)), **args) return fig, ax, qv, sm
def opyfQuiverFieldColored(self, grid_x, grid_y, gridVx, gridVy, res=32, normalize=False, **args): from matplotlib.colors import Normalize cmap = self.cmap # one over N # Select randomly N vectors l, c = grid_x.shape resx = np.absolute(grid_x[0, 1]-grid_x[0, 0]) resy = np.absolute(grid_y[1, 0]-grid_y[0, 0]) densx = int(np.round(res/resx)) densy = int(np.round(res/resy)) lvec = np.arange(densy/2, l-densy/2, densy, dtype=int)+(l % densy)//2 cvec = np.arange(densx/2, c-densx/2, densx, dtype=int)+(c % densx)//2 new_grid_x = np.zeros(len(lvec)) size = (len(lvec), len(cvec)) temp_grid_x = grid_x[lvec, :] new_grid_x = temp_grid_x[:, cvec] temp_grid_y = grid_y[lvec, :] new_grid_y = temp_grid_y[:, cvec] new_gridVx = np.zeros(size) new_gridVy = np.zeros(size) for i in range(size[0]): for j in range(size[1]): new_gridVx[i, j] = np.mean( gridVx[lvec[i]-densy//2:lvec[i]+densy//2+1, cvec[j]-densx//2:cvec[j]+densx//2+1]) new_gridVy[i, j] = np.mean( gridVy[lvec[i]-densy//2:lvec[i]+densy//2+1, cvec[j]-densx//2:cvec[j]+densx//2+1]) TargetPoints = Interpolate.npGrid2TargetPoint2D( new_grid_x, new_grid_y) Velocities = Interpolate.npGrid2TargetPoint2D(new_gridVx, new_gridVy) Norme = (Velocities[:, 0]**2+Velocities[:, 1]**2)**0.5 if 'vlim' in args: vlim = args.get('vlim', [Norme.min(), Norme.max()]) if vlim is None: vlim = [Norme.min(), Norme.max()] del args['vlim'] else: vlim = [Norme.min(), Norme.max()] norm = Normalize() norm.autoscale(Norme) norm.vmin = vlim[0] norm.vmax = vlim[1] self.im = mpl.cm.ScalarMappable(cmap=cmap, norm=norm) self.im.set_array([]) if self.ax.get_ylim()[0] > self.ax.get_ylim()[1]: Velocities[:, 1] = -Velocities[:, 1] if normalize == False: qv = self.ax.quiver(TargetPoints[:, 0], TargetPoints[:, 1], Velocities[:, 0], Velocities[:, 1], color=cmap(norm(Norme)), **args) else: qv = self.ax.quiver(TargetPoints[:, 0], TargetPoints[:, 1], Velocities[:, 0] / Norme[:], Velocities[:, 1]/Norme[:], color=cmap(norm(Norme)), **args)
def opyfQuiverPointCloudColored(X, V, fig=None, ax=None, nvec=3000, normalize=False, **args): from matplotlib.colors import Normalize if 'cmap' not in args: args['cmap'] = mpl.cm.coolwarm cmap = args.get('cmap', mpl.cm.coolwarm) del args['cmap'] fig, ax = getax(fig=fig, ax=ax) # one over N # Select randomly N vectors if len(X) < nvec: N = len(X) else: N = nvec print('only '+str(N)+'vectors ave been plotted because the number of velocity vectors is >' + str(nvec)) # print('use the *nvec* parameter to change the number of vecors displayed') ind = np.random.choice(np.arange(len(X)), N, replace=False) Xc = X[ind, :] Vc = V[ind, :] colors = (Vc[:, 0]**2+Vc[:, 1]**2)**0.5 if len(colors) == 0: colors = np.array([0]) if 'vlim' in args: vlim = args.get('vlim', [colors.min(), colors.max()]) if vlim is None: vlim = [colors.min(), colors.max()] del args['vlim'] else: vlim = [colors.min(), colors.max()] norm = Normalize() norm.autoscale(colors) norm.vmin = vlim[0] norm.vmax = vlim[1] sm = mpl.cm.ScalarMappable(cmap=cmap, norm=norm) sm.set_array([]) if ax.get_ylim()[0] > ax.get_ylim()[1]: Vc[:, 1] = -Vc[:, 1] if normalize == False: qv = ax.quiver(Xc[:, 0], Xc[:, 1], Vc[:, 0], Vc[:, 1], color=cmap(norm(colors)), **args) else: qv = ax.quiver(Xc[:, 0], Xc[:, 1], Vc[:, 0]/colors, Vc[:, 1]/colors, color=cmap(norm(colors)), **args) return fig, ax, qv, sm
def draw_intensity(cal: Task, cmap='inferno', norm=None, field_axis='x', vmin=0.98, vmax=1.02, ax=None, colorbar=True, cell_length=100, cell_diameter=60): if norm is None: norm = Normalize() if ax is None: f, ax = plt.subplots() else: f = ax.figure for source in cal.sources: draw_source(ax, source) if field_axis == 'x': field = cal.x_field elif field_axis == 'y': field = cal.y_field else: raise ValueError( "Intensity plot: only x or y accepted for field axis, got %s " % field_axis) norm.vmin = cal.center_field[0] * vmin norm.vmax = cal.center_field[0] * vmax color_plot = ax.pcolor(cal.x_mesh, cal.y_mesh, field, norm=norm, cmap=cmap) ax.axis('equal') draw_cell_boundary(ax, cell_length, cell_diameter) draw_mesh_boundary(cal.mesh, ax) if colorbar: color_bar = f.colorbar(color_plot, ax=ax) color_bar.ax.set_ylabel('%s field/ Tesla' % field_axis) # labels ax.set_xlabel('Position / mm, axial') ax.set_ylabel('Position / mm, radial') ax.autoscale() return color_plot, f, ax
def show_matrix( mat: np.ndarray, label: str, map: str = "clustermap", sort: bool = False, norm: Normalize = LogNorm(), cmap: str = "Greys", fig: Figure = None, ax: Axes = None, title: str = "matrix", **kwargs, ) -> Tuple[Union[Figure, ClusterGrid], Axes]: """ Plot matrix where x and y are the indices of the matrix and z (or c) is the value. :param mat: Matrix to plot. :param label: The data represented by the matrix. E.g. Number of interactions. :param map: How to plot the matrix. * 'clustermap' - `sns.clustermap` * 'heatmap' - `sns.heatmap` * 'mesh' - `matplotlib.pcolormesh` * callable - calls the function using the (potentially generated) ax, norm, and keywords. :param sort: Sort the matrix by most interactions. :param norm: The scale of the plot (normal, log, etc.). :param cmap: Colormap to use. :param ax: Axes to use for plot. Created if none passed. :param fig: Figure to use for colorbar. Created if none passed. :param title: Include title in the figure. :keyword cbar_ax: Axes to use for plotting the colorbar. :return: Tuple[Figure, Axes] used. """ if isinstance(mat, np.ndarray): N, M = mat.shape agent_mat = pd.DataFrame( mat, columns=pd.Index(np.arange(M), name="i"), index=pd.Index(np.arange(N), name="j"), ) elif isinstance(mat, pd.DataFrame): N, M = mat.shape agent_mat = mat else: raise ValueError( f"wrong type of matrix passed to `show_matrix`. Expected `np.ndarray` or `pd.DataFrame` but got {type(mat)}" ) if sort: if map == "mesh": logger.warning( "'mesh' loses agent index information when sorting adjacency matrix" ) agent_mat = agent_mat.sort_values(by=list(agent_mat.index), axis="index").sort_values( by=list(agent_mat.columns), axis="columns") show_matrix.sorted_mat = agent_mat # default label for colorbar cbar_kws = {"label": label, **kwargs.pop("cbar_kws", {})} if "vmin" in kwargs: norm.vmin = kwargs.pop("vmin") if "vmax" in kwargs: norm.vmax = kwargs.pop("vmax") if map == "clustermap": if fig: plt.close(fig) fig = sns.clustermap(agent_mat, norm=norm, cmap=cmap, cbar_kws=cbar_kws, **kwargs) ax = fig.ax_heatmap elif map == "heatmap": sns.heatmap( agent_mat, norm=norm, cmap=cmap, ax=ax, cbar_kws=cbar_kws, **kwargs, ) ax.invert_yaxis() elif map == "mesh": mesh = ax.pcolormesh(agent_mat, norm=norm, cmap=cmap, **kwargs) ax.set_xlim(0, N) ax.set_ylim(0, M) cax = cbar_kws.pop("cbar_ax", None) or cbar_kws.pop("cax", None) if cax is None: colorbar_inset( ScalarMappable(norm=norm, cmap=cmap), "outer right", size="5%", ax=ax, cmap=cmap, **cbar_kws, ) elif isinstance(cax, Axes): # using existing cax fig.colorbar( mesh, cax=cax, **cbar_kws, ) elif cax: # steal space from ax if cax is anything else (i.e. unless None, False, or an Axes) fig.colorbar(mesh, ax=ax, **cbar_kws) elif isinstance(map, Callable): map(agent_mat, ax=ax, norm=norm, **kwargs) else: raise NotImplementedError( f"Method {map} not implemented. Try one of 'clustermap' 'heatmap' 'mesh' or a " f"function.") ax.set_xlabel("Agent $i$") ax.set_ylabel("Agent $j$") if title: if map == "clustermap": fig.fig.suptitle(title) else: ax.set_title(title) # default to borders sns.despine(ax=ax, top=False, right=False, left=False, bottom=False) return fig, ax
def __init__(self, fig, cmap=None, norm=None, limit_func=None, auto_redraw=True, interpolation=None, aspect='equal'): self._cursor_position_cbs = [] if interpolation is None: interpolation = _INTERPOLATION[0] self._interpolation = interpolation # used to determine if setting properties should force a re-draw self._auto_redraw = auto_redraw # clean defaults if limit_func is None: limit_func = fullrange_limit_factory() if cmap is None: cmap = 'gray' # stash the color map self._cmap = cmap # set the default norm if not passed if norm is None: norm = Normalize() # always set the vmin/vmax as we can not auto-limit with an empty array # below. When we set the data we are going to fully rescale this # anyway. norm.vmin, norm.vmax = 0, 1 self._norm = norm # save a copy of the limit function, we will need it later self._limit_func = limit_func # this is used by the widget logic self._active = True self._dirty = True self._cb_dirty = True # work on setting up the mpl axes self._fig = fig # blow away what ever is currently on the figure fig.clf() # Configure the figure in our own image # # +----------------------+ # | H cross section | # +----------------------+ # +---+ +----------------------+ # | V | | | # | | | | # | x | | | # | s | | Main Axes | # | e | | | # | c | | | # | t | | | # | i | | | # | o | | | # | n | | | # +---+ +----------------------+ # make the main axes self._im_ax = fig.add_subplot(1, 1, 1) self._im_ax.set_aspect(aspect) self._im_ax.xaxis.set_major_locator(NullLocator()) self._im_ax.yaxis.set_major_locator(NullLocator()) self._imdata = None self._im = self._im_ax.imshow( [[]], cmap=self._cmap, norm=self._norm, interpolation=self._interpolation, aspect=aspect, ) # make it dividable divider = make_axes_locatable(self._im_ax) # set up all the other axes # (set up the horizontal and vertical cuts) self._ax_h = divider.append_axes('top', .5, pad=0.1, sharex=self._im_ax) self._ax_h.yaxis.set_major_locator(LinearLocator(numticks=2)) self._ax_v = divider.append_axes('left', .5, pad=0.1, sharey=self._im_ax) self._ax_v.xaxis.set_major_locator(LinearLocator(numticks=2)) self._ax_cb = divider.append_axes('right', .2, pad=.5) # add the color bar self._cb = fig.colorbar(self._im, cax=self._ax_cb) # add the cursor place holder self._cur = None # turn off auto-scale for the horizontal cut self._ax_h.autoscale(enable=False) # turn off auto-scale scale for the vertical cut self._ax_v.autoscale(enable=False) # create line artists self._ln_v, = self._ax_v.plot([], [], 'k-', animated=True, visible=False) self._ln_h, = self._ax_h.plot([], [], 'k-', animated=True, visible=False) # backgrounds for blitting self._ax_v_bk = None self._ax_h_bk = None # stash last-drawn row/col to skip if possible self._row = None self._col = None # make attributes for callback ids self._move_cid = None self._click_cid = None self._clear_cid = None