def export(data, F, k): '''Write data to a png image Arguments --------- data : numpy.ndarray array containing the data to be written as png image F : float feed rate of the current configuration k : float rate constant of the current configuration ''' figsize = tuple(s / 72.0 for s in data.shape) fig = plt.figure(figsize=figsize, dpi=72.0, facecolor='white') fig.add_axes([0, 0, 1, 1], frameon=False) plt.xticks([]) plt.yticks([]) plt.imshow(data, cmap=plt.cm.RdBu_r, interpolation='bicubic') plt.gci().set_clim(0, 1) filename = './study/F{:03d}-k{:03d}.png'.format(int(1000*F), int(1000*k)) plt.savefig(filename, dpi=72.0) plt.close()
def plot(f, n=100): '''Plot function over the standard quadrilateral. ''' import matplotlib.tri import matplotlib.pyplot as plt x = numpy.linspace(-1, +1, n) y = numpy.linspace(-1, +1, n) X, Y = numpy.meshgrid(x, y) XY = numpy.stack([X, Y]) z = numpy.array(f(XY), dtype=float) triang = matplotlib.tri.Triangulation(X.flatten(), Y.flatten()) plt.tripcolor(triang, z.flatten(), shading='flat') plt.colorbar() # Choose a diverging colormap such that the zeros are clearly # distinguishable. plt.set_cmap('coolwarm') # Make sure the color map limits are symmetric around 0. clim = plt.gci().get_clim() mx = max(abs(clim[0]), abs(clim[1])) plt.clim(-mx, mx) # quad outlines X = numpy.array([[-1, 1, 1, -1, -1], [-1, -1, 1, 1, -1]]) plt.plot(X[0], X[1], '-k') plt.gca().set_aspect('equal') plt.axis('off') return
def show_matched_boxes(self, image, anchor_polygons, gt_polygons): """ Args: anchor_polygons (np.array): in format (x1, y1, x2, y2, x3, y3, x4, y4) gt_polygons (np.array): in format (x1, y1, x2, y2, x3, y3, x4, y4) Returns: """ h, w, c = image.shape for anchor_polygon, gt_polygon in zip(anchor_polygons, gt_polygons): plt.imshow(image) ax = plt.gca() im = plt.gci() anchor_polygon = (anchor_polygon * 512).reshape((-1, 2)) gt_polygon = (gt_polygon * 512).reshape((-1, 2)) ax.add_patch( plt.Polygon(anchor_polygon, fill=False, color=[1.0, 0.0, 0.0, 1.0], linewidth=1)) ax.add_patch( plt.Polygon(gt_polygon, fill=False, color=[0.0, 1.0, 0.0, 1.0], linewidth=1)) plt.show() plt.close()
def plot_results(self, results=None, classes=None, show_labels=True, gt_data=None, confidence_threshold=None): if results is None: results = self.results if confidence_threshold is not None: mask = results[:, 4] > confidence_threshold results = results[mask] if classes is not None: colors = plt.cm.hsv(np.linspace(0, 1, len(classes)+1)).tolist() ax = plt.gca() im = plt.gci() image_size = im.get_size() # draw ground truth if gt_data is not None: for box in gt_data: label = np.nonzero(box[4:])[0][0]+1 color = 'g' if classes == None else colors[label] xy_rec = to_rec(box[:4], image_size) ax.add_patch(plt.Polygon(xy_rec, fill=True, color=color, linewidth=1, alpha=0.3)) # draw prediction for r in results: label = int(r[5]) confidence = r[4] color = 'r' if classes == None else colors[label] xy_rec = to_rec(r[:4], image_size) ax.add_patch(plt.Polygon(xy_rec, fill=False, edgecolor=color, linewidth=2)) if show_labels: label_name = label if classes == None else classes[label] xmin, ymin = xy_rec[0] display_txt = '%0.2f, %s' % (confidence, label_name) ax.text(xmin, ymin, display_txt, bbox={'facecolor':color, 'alpha':0.5})
def locate_spot(event): """ Callback function for key_press_event from matplotlib. Stores the location of a spot the graph, for later use. Press "m" to store. """ global fignum_one global fignum_two if event.key == 'm': canv = event.canvas # Have to manually reset focus to the figure or else it breaks after first use plt.figure(canv.figure.number) ax = event.inaxes x = np.rint(event.xdata).astype(np.int) y = np.rint(event.ydata).astype(np.int) # append in opposite order because y = row, x = column adj_locs = fc(plt.gci().get_array().data, [[y, x]]) if canv.figure.number == fignum_one: spot_locs_one.append(adj_locs[0]) elif canv.figure.number == fignum_two: spot_locs_two.append(adj_locs[0]) else: print( 'Key press was detected in figure number {}, but only figure numbers {} and {} are valid. Close the program and try again?' .format(canv.figure.number, fignum_one, fignum_two)) raise ValueError ax.plot(adj_locs[-1][1], adj_locs[-1][0], 'ro') canv.draw() print('Point: ({:d}, {:d}) Figure: {}'.format(adj_locs[-1][1], adj_locs[-1][0], canv.figure.number))
def sync_axes(axes_list, axis, lim=()): assert axis in ['x', 'y', 'c'] if len(lim) == 0: axis_min = np.inf axis_max = -np.inf for ax in axes_list: plt.sca(ax) if axis == 'x': axis_lims = plt.gca().get_xlim() elif axis == 'y': axis_lims = plt.gca().get_ylim() elif axis == 'c': axis_lims = plt.gci().get_clim() else: raise Exception axis_min = min(axis_lims[0], axis_min) axis_max = max(axis_lims[1], axis_max) if axis_min == axis_max: axis_max = axis_min + 1e-3 else: axis_min = lim[0] axis_max = lim[1] for ax in axes_list: plt.sca(ax) if axis == 'x': plt.xlim(axis_min, axis_max) elif axis == 'y': plt.ylim(axis_min, axis_max) elif axis == 'c': plt.clim(axis_min, axis_max)
def plot_box(box, box_format='xywh', color='r', linewidth=1, normalized=False, vertices=False): if box_format == 'xywh': # opencv xmin, ymin, w, h = box xmax, ymax = xmin + w, ymin + h elif box_format == 'xyxy': xmin, ymin, xmax, ymax = box if box_format == 'polygon': xy_rec = np.reshape(box, (-1, 2)) else: xy_rec = np.array([[xmin, ymin], [xmax, ymin], [xmax, ymax], [xmin, ymax]]) if normalized: im = plt.gci() xy_rec = xy_rec * np.tile(im.get_size(), (4, 1)) ax = plt.gca() ax.add_patch( plt.Polygon(xy_rec, fill=False, edgecolor=color, linewidth=linewidth)) if vertices: c = 'rgby' for i in range(4): plt.plot(xy_rec[i, 0], xy_rec[i, 1], c[i], marker='o', markersize=4)
def plot_assignment(self, map_idx): ax = plt.gca() im = plt.gci() image_h, image_w = image_size = im.get_size() # ground truth boxes = self.gt_boxes boxes_x = (boxes[:, 0] + boxes[:, 2]) / 2. * image_w boxes_y = (boxes[:, 1] + boxes[:, 3]) / 2. * image_h for box in boxes: xy_rec = to_rec(box[:4], image_size) ax.add_patch( plt.Polygon(xy_rec, fill=False, edgecolor='b', linewidth=2)) plt.plot(boxes_x, boxes_y, 'bo', markersize=6) # prior boxes for idx, box_idx in self.match_indices.items(): if idx >= self.map_offsets[map_idx] and idx < self.map_offsets[ map_idx + 1]: x, y = self.priors_xy[idx] w, h = self.priors_wh[idx] plt.plot(x, y, 'ro', markersize=4) plt.plot([x, boxes_x[box_idx]], [y, boxes_y[box_idx]], '-r', linewidth=1) ax.add_patch( plt.Rectangle((x - w / 2, y - h / 2), w + 1, h + 1, fill=False, edgecolor='y', linewidth=2))
def plot(f, n=100, d=1.0): import matplotlib.tri import matplotlib.pyplot as plt x = numpy.linspace(-d, +d, n) y = numpy.linspace(-d, +d, n) X, Y = numpy.meshgrid(x, y) XY = numpy.stack([X, Y]) z = numpy.array(f(XY), dtype=float) triang = matplotlib.tri.Triangulation(X.flatten(), Y.flatten()) plt.tripcolor(triang, z.flatten(), shading='flat') plt.colorbar() # Choose a diverging colormap such that the zeros are clearly # distinguishable. plt.set_cmap('coolwarm') # Make sure the color map limits are symmetric around 0. clim = plt.gci().get_clim() mx = max(abs(clim[0]), abs(clim[1])) plt.clim(-mx, mx) plt.gca().set_aspect('equal') plt.axis('off') return
def plot_gt(self, boxes, show_labels=True): # if parameter is sample index if type(boxes) in [int]: boxes = self.data[boxes] ax = plt.gca() im = plt.gci() w, h = im.get_size() for box in boxes: class_idx = int(box[-1]) color = self.colors[class_idx] is_polygon = len(box)-1 > 4 if is_polygon: xy = box[:-1].reshape((-1,2)) else: xmin, ymin, xmax, ymax = box[:4] xy = np.array([[xmin, ymin], [xmax, ymin], [xmax, ymax], [xmin, ymax]]) xy = xy * [h, w] ax.add_patch(plt.Polygon(xy, fill=False, edgecolor=color, linewidth=1)) if show_labels: label_name = self.classes[class_idx] if is_polygon: angle = np.arctan((xy[1,0]-xy[0,0])/(xy[1,1]-xy[0,1]+eps)) if angle < 0: angle += np.pi angle = angle/np.pi*180-90 else: angle = 0 ax.text(xy[0,0], xy[0,1], label_name, bbox={'facecolor':color, 'alpha':0.5}, rotation=angle)
def makeGuessAboutCmap(clim=None, colormap=None): if clim: vmin, vmax = clim[0], clim[1] else: vmin, vmax = plt.gci().get_clim() cutOffFrac = 0.5 if -vmin < vmax and -vmin / vmax > cutOffFrac: vmin = -vmax elif -vmin > vmax and -vmax / vmin > cutOffFrac: vmax = -vmin if vmin == vmax: if debug: print('vmin,vmax=', vmin, vmax) vmin = vmin - 1 vmax = vmax + 1 plt.clim(vmin, vmax) if colormap: plt.set_cmap(colormap) else: if vmin * vmax >= 0 and vmax > 0 and 3 * vmin < vmax: plt.set_cmap('plasma') # Single signed +ve data elif vmin * vmax >= 0 and vmin < 0 and 3 * vmax > vmin: plt.set_cmap('plasma_r') # Single signed -ve data elif abs((vmax + vmin) / (vmax - vmin)) < .01: plt.set_cmap('seismic') # Multi-signed symmetric data else: plt.set_cmap('viridis') landColor = [.5, .5, .5] plt.gca().set_facecolor(landColor) return (vmin, vmax)
def animateImages(images: list, titles: list = None, dpi: int = None, save_name: str = "_temp", frame_interval: int = 60, repeat_delay: int = 1000, cmap: Union[str, Colormap] = 'viridis', verbose: bool = False): assert type(images) is list, "Images should be list or dict." assert len(images) != 0, "Images is empty." from matplotlib import animation from sys import stdout as stdout _str_stdout = "" if verbose: _str_stdout = "Compiling Figures: 0 % / 100 %" stdout.write(_str_stdout) _frames = [] n_img = len(images) _fig = plt.figure(dpi=dpi) for i in range(n_img): plt.imshow(images[i], animated=True) plt.xticks([]), plt.yticks([]) plt.set_cmap(cmap) title = "" try: title = plt.text(0.5, 1.01, titles[i], horizontalalignment='center', verticalalignment='bottom', transform=plt.gca().transAxes) except IndexError: pass _frames.append([plt.gci(), title]) if verbose: for _ in _str_stdout: stdout.write("\b") _str_stdout = f"Compiling figures: " \ f"{int(np.round(i * 100 / n_img))} % / 100 %" stdout.write(_str_stdout) stdout.write("\nCreating animation object, this may take a while.") ani = animation.ArtistAnimation(_fig, _frames, interval=frame_interval, blit=True, repeat_delay=repeat_delay) stdout.write(f"\nSaving to figures {save_name}, this may take a while.") try: ani.save(f'{save_name}.mp4') except ValueError: ani.save(f'{save_name}.gif') return
def visualize_deviation_matrix(S, fs_act, list_iois, xlim=None, clim=None, colorbar=True): from matplotlib.colors import LinearSegmentedColormap tolerance = int((S.shape[0] - 1) / 2) left = -1 / 2 right = S.shape[1] - 1 / 2 lower = -tolerance / fs_act upper = tolerance / fs_act matrix_to_show = S.copy() matrix_to_show += 10**-1 matrix_to_show[matrix_to_show <= 0] = np.nan matrix_to_show -= 10**-1 # get the colormap right log_comp = 100 log_series = np.log((np.linspace(start=1, stop=log_comp, num=256))) min_val = 0.07 scaled_series = log_series / np.max(log_series) * (1 - min_val) + min_val gray_values = 1 - scaled_series gray_values_rgb = np.repeat(gray_values.reshape(256, 1), 3, axis=1) color_wb = LinearSegmentedColormap.from_list('color_wb', gray_values_rgb, N=256) im = plt.imshow(matrix_to_show, aspect='auto', extent=[left, right, lower, upper], origin='lower', cmap=color_wb) if colorbar: plt.colorbar() plt.plot(list_iois / 2, 'k') plt.plot(-list_iois / 2, 'k') plt.ylim([lower, upper]) if xlim is not None: plt.xlim(xlim) if clim is not None: plt.clim(clim[0], clim[1]) else: clim = plt.gci().get_clim() plt.xlabel('Tap index') plt.ylabel('Deviation (sec)') return im, clim
def clim_std(stdfac=1,ih=None): if not ih: ih = plt.gci() #ihandles = h.findobj(matplotlib.image.AxesImage) #ih = ihandles[-1] im = ih.get_array() imean = np.median(im.ravel()[~np.isnan(im.ravel())]) istd = mad(im.ravel()[~np.isnan(im.ravel())]) ih.set_clim([imean-stdfac*istd,imean+stdfac*istd]) plt.draw_if_interactive()
def save_image(path, data, colorbar=True, background=None, clim=None, title=None, size=(3, 3), dpi=500, xlim=None, ylim=None, sym=True): from numpy import abs, max with mpl.rc_context(rc=rc): plt.ioff() fig = plt.figure() extent = None if xlim and ylim: extent = [*xlim, *ylim] if background is None: if sym: plt.imshow(data, extent=extent, cmap='coolwarm') clim = plt.gci().get_clim() clim = max(abs(clim)) plt.gci().set_clim([-clim, clim]) else: plt.imshow(data, clim=clim, extent=extent) else: plt.imshow(background, cmap='Greys', extent=extent) plt.imshow(colormap(data, clim=clim), extent=extent) if title: plt.title(title, fontdict={'fontsize': 'xx-small'}) if colorbar: plt.colorbar() fig.set_size_inches(size) fig.savefig(path, dpi=dpi, facecolor='white') plt.close()
def inverseGray(): ''' set the default colormap to gray and apply to current image if any. See help(colormaps) for more information ''' _plt.rc('image', cmap='gray_r') im = _plt.gci() if im is not None: im.set_cmap(_plt.cm.gray_r) _plt.draw_if_interactive()
def plotspectrogram(data: np.ndarray, fs: int, nmode: str): fg = figure() ax = fg.gca() Pxx, freqs, bins, im = specgram(data, NFFT=NFFT, Fs=fs, noverlap=500) fg.colorbar(gci(), ax=ax) ax.set_title(f"{nmode} noise") ax.set_xlabel("time (sec.)") ax.set_ylabel("frequency (Hz)")
def linecut(width=1,plot=True,pts=None,data=None,\ avg_profiles=True,mode='nearest',**kwargs): import numpy as np from scipy import ndimage from_image = False if hasattr(data, 'get_array'): im = data from_image = True elif data is None: im = plt.gci() assert im is not None, 'No current image, so provide explicit `data`!' from_image = True else: data = np.asarray(data) from_image = False if from_image: data = im.get_array().T #Transpose because axes are swtiched in image if pts is not None: pt1, pt2 = pts else: PP = PointPicker(max_pts=2, verbose=True, mousebutton=3) pt1, pt2 = PP.get_points() (x1, y1), (x2, y2) = pt1, pt2 N = int(numpy.sqrt((x2 - x1)**2 + (y2 - y1)**2)) angle = numpy.arctan2(y2 - y1, x2 - x1) dx, dy = numpy.sin(angle), -numpy.cos(angle) profiles = [] for lineno in range(int(width)): xoffset = (width / 2 - .5 - lineno) * dx yoffset = (width / 2 - .5 - lineno) * dy xi, yi = x1 + xoffset, y1 + yoffset xf, yf = x2 + xoffset, y2 + yoffset xs = numpy.linspace(xi, xf, N) ys = numpy.linspace(yi, yf, N) if from_image and plot: X1, X2, Y1, Y2 = im.get_extent() dX = (X2 - X1) / data.shape[0] Xs = X1 + xs * dX dY = (Y2 - Y1) / data.shape[1] Ys = Y1 + ys * dY im.axes.plot(Xs, Ys, color='k', alpha=.5) profile = ndimage.map_coordinates(data, np.vstack((xs,ys)),\ mode=mode,**kwargs) profiles.append(profile) if avg_profiles: return numpy.mean(profiles, axis=0) else: return numpy.array(profiles)
def onclick(event): global cid2 # event from matplotlib x = event.xdata; y = event.ydata xndx = np.where(mass_vec_edges < x)[0][-1] yndx = np.where(age_vec_edges < y)[0][-1] mass = np.int(mass_vec[xndx]) age = np.int(age_vec[yndx]) mass_str = str(mass).zfill(3) age_str = str(age).zfill(4) name_str = path + "spec_" + ATM_TYPE + "_mass_" + mass_str + "_age_" + age_str + ".txt" print name_str data = np.loadtxt(name_str) this_Si_vec = data[1:,0] this_Si_vec_edges = get_cell_edges(this_Si_vec) yval_edges = np.array([-1.,1.]) xval_edges = this_Si_vec_edges xvalA,yvalA = np.meshgrid(xval_edges,yval_edges) zvalA = np.zeros_like(xvalA) for ii in range(len(this_Si_vec)): zvalA[0,ii] = this_Si_vec[ii] plt.figure(2,figsize=(8,3)) plt.pcolor(xvalA,yvalA,zvalA,edgecolors='k') hh = plt.gci() ax2 = plt.gca() loc = plticker.MultipleLocator(base=0.5) ax.xaxis.set_major_locator(loc) ax2.set_xlim([min(xval_edges),max(xval_edges)]) plt.gca().yaxis.set_major_locator(plt.NullLocator()) title_str = 'Mass: ' + str(mass) + ' Mjup; Age: ' + str(age) + ' Myr; ' + \ ' Click to select the initial entropy.' plt.title(title_str) plt.xlabel('Initial Entropy (kB/baryon)') def onclick2(event2): x2 = event2.xdata; y2 = event2.ydata print x2, this_Si_vec_edges rgb = hh.cmap(hh.norm(x2))[:-1] # last element is alpha (transparency) xndx2 = np.where(this_Si_vec_edges < x2)[0][-1] print len(this_Si_vec_edges),'****',name_str this_spec_row_ndx = 1+xndx2 print this_spec_row_ndx this_spec = data[this_spec_row_ndx,1:] plt.figure(3,figsize=(6,6)) plt.plot(lambdas,this_spec,color=rgb) plt.xlabel('Wavelength (microns)') plt.ylabel('Flux (mJy)') print "***********", x2, rgb, this_spec_row_ndx, this_spec[:5] plt.show() plt.ion() if not cid2 is None: plt.disconnect(cid2) cid2 = plt.connect('button_press_event',onclick2) plt.show()
def divergentMesh(X, Y, Z, xlabel='x', ylabel='y', vmax=None, generateCBAR=True, zOrder=None, plotOptions={}): vmin0, vmax0 = None, None absmax = np.abs(Z).max() if vmax is None: vmax = absmax if not generateCBAR: vmin0, vmax0 = plt.gci().get_clim() if vmin0 is None: vmin0, vmax0 = -vmax, vmax vmin, vmax = vmin0, vmax0 print(vmax) # plt.set_cmap('bwr') # plt.pcolormesh(X,Y,Z,cmap='inferno',vmin=vmin, vmax=vmax,linewidth=0,rasterized=True) # plt.pcolormesh(X,Y,Z,cmap=BKR_cmap,vmin=-vmax, vmax=vmax,linewidth=0,rasterized=True) if zOrder is not None: # plt.pcolormesh(X,Y,Z,vmin=-vmax, vmax=vmax,linewidth=0,rasterized=True, zorder=zOrder, **plotOptions) plt.pcolormesh(X, Y, Z, cmap=fireIce_cmap, vmin=-vmax, vmax=vmax, linewidth=0, rasterized=True, zorder=zOrder, **plotOptions) else: # plt.pcolormesh(X,Y,Z,vmin=-vmax, vmax=vmax,linewidth=0,rasterized=True, **plotOptions) plt.pcolormesh(X, Y, Z, cmap=fireIce_cmap, vmin=-vmax, vmax=vmax, linewidth=0, rasterized=True, **plotOptions) plt.xlabel(xlabel) plt.ylabel(ylabel) if generateCBAR: cbar = plt.colorbar() return cbar return None
def draw(self): """Draw the reaction.""" plt.axis([0, self.rows, 0, self.cols]) plt.xticks([]) plt.yticks([]) shared_options = dict(interpolation='bicubic', vmin=None, vmax=None, alpha=0.3, origin='upper', extent=[0, self.rows, 0, self.cols]) plt.imshow(self.array_a, cmap='twilight', **shared_options) plt.imshow(self.array_b, cmap='cool', **shared_options) self.image = plt.gci()
def defaultMesh(X, Y, Z, xlabel='x', ylabel='y', vmin=None, vmax=None, generateCBAR=True, zOrder=None, plotOptions={}): vmin0, vmax0 = vmin, vmax if (not generateCBAR): vmin0, vmax0 = plt.gci().get_clim() if vmin0 is None: vmin0, vmax0 = vmin, vmax vmin, vmax = vmin0, vmax0 print(vmin, vmax) # plt.pcolormesh(X,Y,Z,cmap='inferno',vmin=vmin, vmax=vmax,linewidth=0,rasterized=True) # plt.pcolormesh(X,Y,Z,cmap=KR_cmap,vmin=vmin, vmax=vmax,linewidth=0,rasterized=True) if zOrder is not None: plt.pcolormesh(X, Y, Z, cmap=fire_cmap, vmin=vmin, vmax=vmax, linewidth=0, rasterized=True, zorder=zOrder, **plotOptions) else: plt.pcolormesh(X, Y, Z, cmap=fire_cmap, vmin=vmin, vmax=vmax, linewidth=0, rasterized=True, **plotOptions) plt.xlabel(xlabel) plt.ylabel(ylabel) if generateCBAR: cbar = plt.colorbar() return cbar return None
def plot(corners, f, n=100): '''Plot function over a triangle. ''' import matplotlib.tri import matplotlib.pyplot as plt # discretization points def partition(boxes, balls): # <https://stackoverflow.com/a/36748940/353337> def rec(boxes, balls, parent=tuple()): if boxes > 1: for i in range(balls + 1): for x in rec(boxes - 1, i, parent + (balls - i, )): yield x else: yield parent + (balls, ) return list(rec(boxes, balls)) bary = numpy.array(partition(3, n)).T / n X = numpy.sum([numpy.outer(bary[k], corners[:, k]) for k in range(3)], axis=0).T # plot the points # plt.plot(X[0], X[1], 'xk') x = numpy.array(X[0]) y = numpy.array(X[1]) z = numpy.array(f(bary), dtype=float) triang = matplotlib.tri.Triangulation(x, y) plt.tripcolor(triang, z, shading='flat') plt.colorbar() # Choose a diverging colormap such that the zeros are clearly # distinguishable. plt.set_cmap('coolwarm') # Make sure the color map limits are symmetric around 0. clim = plt.gci().get_clim() mx = max(abs(clim[0]), abs(clim[1])) plt.clim(-mx, mx) # triangle outlines X = numpy.column_stack([corners, corners[:, 0]]) plt.plot(X[0], X[1], '-k') plt.gca().set_aspect('equal') plt.axis('off') return
def spatial_plot_format(var_name, scale): """ Formats TPV spatial plots consistently """ title_str = "TPV effect on " + var_name plt.title(title_str) cbar_str = var_name if scale: cbar_str = cbar_str + " (stdv)" plt.colorbar(fraction=0.023, pad=0.04, label = cbar_str) if var_name != 'grid_count': A, B = plt.gci().get_clim() cmax=np.abs(np.array([A, B])).max() plt.clim(-cmax, cmax) else: A, B = plt.gci().get_clim() cmax=np.abs(np.array([A, B])).max() plt.clim(0, cmax/3) plt.title('Grid box count') plt.axhline(y=0, color='k', linestyle='-') plt.axvline(x=0, color='k', linestyle='-') plt.xlabel('x (km)') plt.ylabel('y (km)')
def sync_clim_axes(axes_list, clim=()): if len(clim) == 0: cmin = np.inf cmax = -np.inf for ax in axes_list: plt.sca(ax) clims = plt.gci().get_clim() cmin = min(clims[0], cmin) cmax = max(clims[1], cmax) if cmin == cmax: cmax = cmin + 1e-3 else: cmin = clim[0] cmax = clim[1] for ax in axes_list: plt.sca(ax) plt.clim(cmin, cmax)
def plot_single(degrees, res=100, scaling="normal", colorbar=True, cmap="RdBu_r", corners=None): import meshzoo from matplotlib import pyplot as plt n = sum(degrees) r = degrees[0] def f(bary): for k, level in enumerate(Eval(bary, scaling)): if k == n: return level[r] if corners is None: alpha = numpy.pi * numpy.array([7.0 / 6.0, 11.0 / 6.0, 3.0 / 6.0]) corners = numpy.array([numpy.cos(alpha), numpy.sin(alpha)]) bary, cells = meshzoo.triangle(res) x, y = numpy.dot(corners, bary) z = numpy.array(f(bary), dtype=float) plt.tripcolor(x, y, cells, z, shading="flat") if colorbar: plt.colorbar() # Choose a diverging colormap such that the zeros are clearly distinguishable. plt.set_cmap(cmap) # Make sure the color map limits are symmetric around 0. clim = plt.gci().get_clim() mx = max(abs(clim[0]), abs(clim[1])) plt.clim(-mx, mx) # triangle outlines X = numpy.column_stack([corners, corners[:, 0]]) plt.plot(X[0], X[1], "-k") plt.gca().set_aspect("equal") plt.axis("off") plt.title( f"Orthogonal polynomial on triangle ([{degrees[0]}, {degrees[1]}], {scaling})" )
def plot(self, showvalues=False, normed=None, cmap=None, log=None, cut=None): ''' Plot the joint statistics histogram generated with :func:`joint` ''' if normed is None: normed = self.normed X, Y = np.meshgrid(self.bins[0], self.bins[1]) if normed: data = self.hist / self.N else: data = self.hist q = -1 if cut: data = data[:3, :3] X = X[:3, :3] Y = Y[:3, :3] q = 2 if log is None or log == False: norm = mpl.colors.Normalize(vmin=data.min(), vmax=data.max()) else: vmin = np.min(data[np.nonzero(data)]) norm = mpl.colors.LogNorm(vmin=vmin, vmax=data.max()) cplt = plt.pcolormesh(X, Y, data, cmap=cmap, norm=norm) ax = plt.gca() ax.set_xticks(self.bins[0][:q] + 0.5) ax.set_xticklabels(np.array(self.bins[0][:q], dtype=np.uint16)) ax.set_yticks(self.bins[1][:q] + 0.5) ax.set_yticklabels(np.array(self.bins[1][:q], dtype=np.uint16)) vmin, vmax = plt.gci().get_clim() cm = cplt.get_cmap() sm = cmx.ScalarMappable(norm=norm, cmap=cm) plt.xlabel('Region 1') plt.ylabel('Region 2') if showvalues: for i, v in np.ndenumerate(data): rgba = opcolor(sm.to_rgba(v)) if normed: plt.text(i[1] + 0.4, i[0] + 0.4, "%.3e" % v, color=rgba) else: plt.text(i[1] + 0.4, i[0] + 0.4, "%d" % v, color=rgba)
def spherical_plot_format(var_name, scale): """ Formats TPV spherical plots consistently """ title_str = "TPV effect on " + var_name plt.title(title_str) cbar_str = var_name if scale: cbar_str = cbar_str + " (stdv)" plt.colorbar(fraction=0.023, pad=0.04, label=cbar_str) A, B = plt.gci().get_clim() cmax = np.abs(np.array([A, B])).max() if var_name != 'grid_count': plt.clim(-cmax, cmax) else: plt.clim(0, cmax) plt.title('Grid box count')
def locate_spot(event): """ Callback function for key_press_event from matplotlib. Stores the location of a spot the graph, for later use. Press "m" to store. """ if event.key == 'm': canv = event.canvas # Have to manually reset focus to the figure or else it breaks after first use plt.figure(canv.figure.number) ax = event.inaxes x = np.rint(event.xdata).astype(np.int) y = np.rint(event.ydata).astype(np.int) # append in opposite order because y = row, x = column adj_locs = fc(plt.gci().get_array().data, [[y, x]]) spot_locs.append(adj_locs[0]) ax.plot(spot_locs[-1][1], spot_locs[-1][0], 'ro') canv.draw() print('Point: ({:d}, {:d})'.format(spot_locs[-1][1], spot_locs[-1][0]))
def plot_reconstruct_stimulus(response, rf, xlims=[18, 27], ylims=[3, 12]): """Reconstruct stimulus using responses and receptive fields """ ss = 0 * rf[:, :, 0] for icell in range(rf.shape[-1] - 1): ss += rf[:, :, icell] * response[icell] ss += rf[:, :, -1] plt.imshow(ss, interpolation='nearest', cmap='gray', clim=(-0.01, 0.01)) plt.grid(False) plt.xticks([]) plt.yticks([]) plt.xlim(xlims) plt.ylim(ylims) print(plt.gci().get_clim()) #plt.xlim([18*2, 27*2]) #plt.ylim([3*2, 12*2]) return ss
def makeGuessAboutCmap(clim=None, colormap=None): if clim: vmin, vmax = clim[0], clim[1] else: vmin, vmax = plt.gci().get_clim() cutOffFrac = 0.5 if -vmin<vmax and -vmin/vmax>cutOffFrac: vmin=-vmax elif -vmin>vmax and -vmax/vmin>cutOffFrac: vmax=-vmin if vmin==vmax: if debug: print('vmin,vmax=',vmin,vmax) vmin = vmin - 1; vmax = vmax + 1 plt.clim(vmin,vmax) if colormap: plt.set_cmap(colormap) else: if vmin*vmax>=0 and vmax>0 and 3*vmin<vmax: plt.set_cmap('plasma') # Single signed +ve data elif vmin*vmax>=0 and vmin<0 and 3*vmax>vmin: plt.set_cmap('plasma_r') # Single signed -ve data elif abs((vmax+vmin)/(vmax-vmin))<.01: plt.set_cmap('seismic') # Multi-signed symmetric data else: plt.set_cmap('viridis') landColor=[.5,.5,.5] plt.gca().set_facecolor(landColor) return (vmin, vmax)
def update(self, data): # check if image exists axesImage = plt.gci() if axesImage is None: # create image axesImage = plt.imshow(data, cmap=self.settings['colormap'], \ interpolation=self.settings['interpolation']) # set new data axesImage.set_data(data) axesImage.set_clim(data.min(), data.max()) # update plot in interactive mode if self.show == True: plt.draw() # write out new image if self.export != None: filename = '{}temp-{:05d}.png'.format(self.export, self.images_written) self.images_written += 1 plt.savefig(filename, dpi=self.settings['dpi'])
def Colorbar(self): ''' return current colorbar colorbar of healpix: use plt.gca() colorbar of plt.pcolor: use plt.gci() == plt.gcf()._gci() (cbar.ax) can be as the input ax in jp.Plt.Axes... ''' import matplotlib.pyplot as plt ax = plt.gca() if ('healpy' in str(ax.__class__)): im = ax.get_images()[-1] else: im = plt.gci() cbar = im.colorbar return cbar
def plot(f, lcar=1.0e-1): '''Plot function over a disk. ''' import matplotlib import matplotlib.pyplot as plt import pygmsh geom = pygmsh.built_in.Geometry() geom.add_circle( [0.0, 0.0, 0.0], 1.0, lcar, num_sections=4, compound=True, ) points, cells, _, _, _ = pygmsh.generate_mesh(geom, verbose=True) x = points[:, 0] y = points[:, 1] triang = matplotlib.tri.Triangulation(x, y, cells['triangle']) plt.tripcolor(triang, f(points.T), shading='flat') plt.colorbar() # Choose a diverging colormap such that the zeros are clearly # distinguishable. plt.set_cmap('coolwarm') # Make sure the color map limits are symmetric around 0. clim = plt.gci().get_clim() mx = max(abs(clim[0]), abs(clim[1])) plt.clim(-mx, mx) # circle outline circle = plt.Circle((0, 0), 1.0, edgecolor='k', fill=False) plt.gca().add_artist(circle) plt.gca().set_aspect('equal') plt.axis('off') return
def set_clim_to_convex_hull(*all_axes): """Set the color scale limits of the given axes to the convex hull of all those specified.""" min_limit = None max_limit = None # Save the current axes so we can restore the context after this function call. current_axes = pyplot.gca() for axes in all_axes: # This is the only public-API method for obtaining 'images' (e.g. a pcolormesh) from each axis. pyplot.sca(axes) image = pyplot.gci() this_min, this_max = image.get_clim() min_limit = this_min if min_limit is None else min(this_min, min_limit) max_limit = this_max if max_limit is None else max(this_max, max_limit) # We now have the new limits, so set everywhere. for axes in all_axes: pyplot.sca(axes) pyplot.clim(min_limit, max_limit) pyplot.sca(current_axes)
def main(): ############################################################################### ##### PARAMETERS ############################################################## ############################################################################### # Some general help descriptions ######### Some general plotting arguments descriptions ############### helpinput = 'The file name of the input Experimental Matrix file. Recommended to add more columns for more information for ploting. For example, cell type or factors.' helpoutput = 'The directory name for the output files. For example, project name.' helptitle = 'The title shown on the top of the plot and also the folder name.' helpgroup = "Group the data by reads(needs 'factor' column), regions(needs 'factor' column), another name of column (for example, 'cell')in the header of experimental matrix, or None." helpgroupbb = "Group the data by any optional column (for example, 'cell') of experimental matrix, or None." helpsort = "Sort the data by reads(needs 'factor' column), regions(needs 'factor' column), another name of column (for example, 'cell')in the header of experimental matrix, or None." helpcolor = "Color the data by reads(needs 'factor' column), regions(needs 'factor' column), another name of column (for example, 'cell')in the header of experimental matrix, or None." helpcolorbb = "Color the data by any optional column (for example, 'cell') of experimental matrix, or None." helpDefinedColot = 'Define the specific colors with the given column "color" in experimental matrix. The color should be in the format of matplotlib.colors. For example, "r" for red, "b" for blue, or "(100, 35, 138)" for RGB.' helpreference = 'The file name of the reference Experimental Matrix. Multiple references are acceptable.' helpquery = 'The file name of the query Experimental Matrix. Multiple queries are acceptable.' parser = argparse.ArgumentParser(description='Provides various Statistical analysis methods and plotting tools for ExperimentalMatrix.\ \nAuthor: Joseph Kuo, Ivan Gesteira Costa Filho', formatter_class=argparse.ArgumentDefaultsHelpFormatter) subparsers = parser.add_subparsers(help='sub-command help',dest='mode') ################### Projection test ########################################## parser_projection = subparsers.add_parser('projection',help='Projection test evaluates the association level by comparing to the random binomial model.') parser_projection.add_argument('-r', metavar=' ', help=helpreference) parser_projection.add_argument('-q', metavar=' ', help=helpquery) parser_projection.add_argument('-o', metavar=' ', help=helpoutput) parser_projection.add_argument('-t', metavar=' ', default='projection_test', help=helptitle) parser_projection.add_argument('-g', metavar=' ', default=None, help=helpgroupbb +" (Default:None)") parser_projection.add_argument('-c', metavar=' ', default="regions", help=helpcolorbb +' (Default: regions)') parser_projection.add_argument('-bg', metavar=' ', default=None, help="Define a BED file as background. If not defined, the background is whole genome according to the given organism.") parser_projection.add_argument('-union', action="store_true", help='Take the union of references as background for binominal test.') parser_projection.add_argument('-organism', metavar=' ', default='hg19', help='Define the organism. (Default: hg19)') parser_projection.add_argument('-log', action="store_true", help='Set y axis of the plot in log scale.') parser_projection.add_argument('-color', action="store_true", help=helpDefinedColot) parser_projection.add_argument('-show', action="store_true", help='Show the figure in the screen.') parser_projection.add_argument('-table', action="store_true", help='Store the tables of the figure in text format.') ################### Intersect Test ########################################## parser_intersect = subparsers.add_parser('intersect',help='Intersection test provides various modes of intersection to test the association between references and queries.') parser_intersect.add_argument('-r', metavar=' ', help=helpreference) parser_intersect.add_argument('-q', metavar=' ', help=helpquery) parser_intersect.add_argument('-o', help=helpoutput) parser_intersect.add_argument('-t', metavar=' ', default='intersection_test', help=helptitle) parser_intersect.add_argument('-g', metavar=' ', default=None, help=helpgroupbb +" (Default:None)") parser_intersect.add_argument('-c', metavar=' ', default="regions", help=helpcolorbb +' (Default: regions)') parser_intersect.add_argument('-organism', metavar=' ', default='hg19', help='Define the organism. (Default: hg19)') parser_intersect.add_argument('-bg', metavar=' ', help="Define a BED file as background. If not defined, the background is whole genome according to the given organism.") parser_intersect.add_argument('-m', metavar=' ', default="count", choices=['count','bp'], help="Define the mode of calculating intersection. \ 'count' outputs the number of overlapped regions.\ 'bp' outputs the coverage(basepair) of intersection.") parser_intersect.add_argument('-tc', metavar=' ', type=int, default=False, help="Define the threshold(in percentage) of reference length for intersection counting. For example, '20' means that the query which overlaps more than 20%% of reference is counted as intersection.") parser_intersect.add_argument('-ex', metavar=' ', type=int, default=0, help="Define the extension(in percentage) of reference length for intersection counting. For example, '20' means that each region of reference is extended by 20%% in order to include proximal queries.") parser_intersect.add_argument('-log', action="store_true", help='Set y axis of the plot in log scale.') parser_intersect.add_argument('-color', action="store_true", help=helpDefinedColot) parser_intersect.add_argument('-show', action="store_true", help='Show the figure in the screen.') parser_intersect.add_argument('-stest', metavar=' ', type=int, default= 0, help='Define the repetition time of random subregion test between reference and query.') ################### Jaccard test ########################################## parser_jaccard = subparsers.add_parser('jaccard',help='Jaccard test evaluates the association level by comparing with jaccard index from repeating randomization.') parser_jaccard.add_argument('-o', help=helpoutput) parser_jaccard.add_argument('-r', '--reference',help=helpreference) parser_jaccard.add_argument('-q', '--query', help=helpquery) parser_jaccard.add_argument('-t','--title', default='jaccard_test', help=helptitle) parser_jaccard.add_argument('-rt','--runtime', type=int, default=500, help='Define how many times to run the randomization. (Default:500)') parser_jaccard.add_argument('-g', default=None, help=helpgroupbb +" (Default:None)") parser_jaccard.add_argument('-c', default="regions", help=helpcolorbb +' (Default: regions)') parser_jaccard.add_argument('-organism',default='hg19', help='Define the organism. (Default: hg19)') parser_jaccard.add_argument('-nlog', action="store_false", help='Set y axis of the plot not in log scale.') parser_jaccard.add_argument('-color', action="store_true", help=helpDefinedColot) parser_jaccard.add_argument('-show', action="store_true", help='Show the figure in the screen.') parser_jaccard.add_argument('-table', action="store_true", help='Store the tables of the figure in text format.') ################### Combinatorial Test ########################################## parser_combinatorial = subparsers.add_parser('combinatorial',help='Combinatorial test compare all combinatorial possibilities from reference to test the association between references and queries.') parser_combinatorial.add_argument('-o', help=helpoutput) parser_combinatorial.add_argument('-r', '--reference',help=helpreference) parser_combinatorial.add_argument('-q', '--query', help=helpquery) parser_combinatorial.add_argument('-t','--title', default='combinatorial_test', help=helptitle) parser_combinatorial.add_argument('-g', default=None, help=helpgroupbb +" (Default:None)") parser_combinatorial.add_argument('-c', default="regions", help=helpcolorbb +' (Default: regions)') parser_combinatorial.add_argument('-organism',default='hg19', help='Define the organism. (Default: hg19)') parser_combinatorial.add_argument('-bg', help="Define a BED file as background. If not defined, the background is whole genome according to the given organism.") parser_combinatorial.add_argument('-m', default="count", choices=['count','bp'], help="Define the mode of calculating intersection. \ 'count' outputs the number of overlapped regions.\ 'bp' outputs the coverage(basepair) of intersection.") parser_combinatorial.add_argument('-tc', type=int, default=False, help="Define the threshold(in percentage) of reference length for intersection counting. For example, '20' means that the query which overlaps more than 20%% of reference is counted as intersection.") parser_combinatorial.add_argument('-ex', type=int, default=0, help="Define the extension(in percentage) of reference length for intersection counting. For example, '20' means that each region of reference is extended by 20%% in order to include proximal queries.") parser_combinatorial.add_argument('-log', action="store_true", help='Set y axis of the plot in log scale.') parser_combinatorial.add_argument('-color', action="store_true", help=helpDefinedColot) parser_combinatorial.add_argument('-show', action="store_true", help='Show the figure in the screen.') parser_combinatorial.add_argument('-stest', type=int, default= 0, help='Define the repetition time of random subregion test between reference and query.') ################### Boxplot ########################################## parser_boxplot = subparsers.add_parser('boxplot',help='Boxplot based on the BAM and BED files for gene association analysis.') parser_boxplot.add_argument('input',help=helpinput) parser_boxplot.add_argument('-o', metavar=' ', help=helpoutput) parser_boxplot.add_argument('-t', metavar=' ', default='boxplot', help=helptitle) parser_boxplot.add_argument('-g', metavar=' ', default='reads', help=helpgroup + " (Default:reads)") parser_boxplot.add_argument('-c', metavar=' ', default='regions', help=helpcolor + " (Default:regions)") parser_boxplot.add_argument('-s', metavar=' ', default='None', help=helpsort + " (Default:None)") parser_boxplot.add_argument('-sy', action="store_true", help="Share y axis for convenience of comparison.") parser_boxplot.add_argument('-nlog', action="store_false", help='Set y axis of the plot not in log scale.') parser_boxplot.add_argument('-color', action="store_true", help=helpDefinedColot) parser_boxplot.add_argument('-nqn', action="store_true", help='No quantile normalization in calculation.') parser_boxplot.add_argument('-df', action="store_true", help="Show the difference of the two signals which share the same labels.The result is the subtraction of the first to the second.") parser_boxplot.add_argument('-ylim', metavar=' ', type=int, default=None, help="Define the limit of y axis.") parser_boxplot.add_argument('-p', metavar=' ', type=float, default=0.05, help='Define the significance level for multiple test. Default: 0.01') parser_boxplot.add_argument('-show', action="store_true", help='Show the figure in the screen.') parser_boxplot.add_argument('-table', action="store_true", help='Store the tables of the figure in text format.') ################### Lineplot ########################################## parser_lineplot = subparsers.add_parser('lineplot', help='Generate lineplot with various modes.') choice_center = ['midpoint','leftend','rightend','bothends'] # Be consist as the arguments of GenomicRegionSet.relocate_regions parser_lineplot.add_argument('input', help=helpinput) parser_lineplot.add_argument('-o', help=helpoutput) parser_lineplot.add_argument('-ga', action="store_true", help="Use genetic annotation data as input regions (e.g. TSS, TTS, exons and introns) instead of the BED files in the input matrix.") parser_lineplot.add_argument('-t', metavar=' ', default='lineplot', help=helptitle) parser_lineplot.add_argument('-center', metavar=' ', choices=choice_center, default='midpoint', help='Define the center to calculate coverage on the regions. Options are: '+', '.join(choice_center) + '.(Default:midpoint) The bothend mode will flap the right end region for calculation.') parser_lineplot.add_argument('-g', metavar=' ', default='reads', help=helpgroup + " (Default:reads)") parser_lineplot.add_argument('-c', metavar=' ', default='regions', help=helpcolor + " (Default:regions)") parser_lineplot.add_argument('-s', metavar=' ', default='None', help=helpsort + " (Default:None)") parser_lineplot.add_argument('-e', metavar=' ', type=int, default=2000, help='Define the extend length of interested region for plotting.(Default:2000)') parser_lineplot.add_argument('-rs', metavar=' ', type=int, default=200, help='Define the readsize for calculating coverage.(Default:200)') parser_lineplot.add_argument('-ss', metavar=' ', type=int, default=50, help='Define the stepsize for calculating coverage.(Default:50)') parser_lineplot.add_argument('-bs', metavar=' ', type=int, default=100, help='Define the binsize for calculating coverage.(Default:100)') parser_lineplot.add_argument('-sy', action="store_true", help="Share y axis for convenience of comparison.") parser_lineplot.add_argument('-sx', action="store_true", help="Share x axis for convenience of comparison.") parser_lineplot.add_argument('-organism', metavar=' ', default='hg19', help='Define the organism. (Default: hg19)') parser_lineplot.add_argument('-color', action="store_true", help=helpDefinedColot) parser_lineplot.add_argument('-mp', action="store_true", help="Perform multiprocessing for faster computation.") parser_lineplot.add_argument('-df', action="store_true", help="Show the difference of the two signals which share the same labels.The result is the subtraction of the first to the second.") parser_lineplot.add_argument('-show', action="store_true", help='Show the figure in the screen.') parser_lineplot.add_argument('-table', action="store_true", help='Store the tables of the figure in text format.') ################### Heatmap ########################################## parser_heatmap = subparsers.add_parser('heatmap', help='Generate heatmap with various modes.') choice_center = ['midpoint','leftend','rightend','bothends'] # Be consist as the arguments of GenomicRegionSet.relocate_regions parser_heatmap.add_argument('input', help=helpinput) parser_heatmap.add_argument('-o', metavar=' ', help=helpoutput) parser_heatmap.add_argument('-ga', action="store_true", help="Use genetic annotation data as input regions (e.g. TSS, TTS, exons and introns) instead of the BED files in the input matrix.") parser_heatmap.add_argument('-t', metavar=' ', default='heatmap', help=helptitle) parser_heatmap.add_argument('-center', metavar=' ', choices=choice_center, default='midpoint', help='Define the center to calculate coverage on the regions. Options are: '+', '.join(choice_center) + '.(Default:midpoint) The bothend mode will flap the right end region for calculation.') parser_heatmap.add_argument('-sort', metavar=' ', type=int, default=None, help='Define the way to sort the signals.'+ 'Default is no sorting at all, the signals arrange in the order of their position; '+ '"0" is sorting by the average ranking of all signals; '+ '"1" is sorting by the ranking of 1st column; "2" is 2nd and so on... ') parser_heatmap.add_argument('-s', metavar=' ', default='None', help=helpsort + " (Default:None)") parser_heatmap.add_argument('-g', metavar=' ', default='regions', help=helpgroup + " (Default:regions)") parser_heatmap.add_argument('-c', metavar=' ', default='reads', help=helpcolor + " (Default:reads)") parser_heatmap.add_argument('-e', metavar=' ', type=int, default=2000, help='Define the extend length of interested region for plotting.(Default:2000)') parser_heatmap.add_argument('-rs', metavar=' ', type=int, default=200, help='Define the readsize for calculating coverage.(Default:200)') parser_heatmap.add_argument('-ss', metavar=' ', type=int, default=50, help='Define the stepsize for calculating coverage.(Default:50)') parser_heatmap.add_argument('-bs', metavar=' ', type=int, default=100, help='Define the binsize for calculating coverage.(Default:100)') parser_heatmap.add_argument('-organism', metavar=' ', default='hg19', help='Define the organism. (Default: hg19)') parser_heatmap.add_argument('-color', action="store_true", help=helpDefinedColot) parser_heatmap.add_argument('-log', action="store_true", help='Set colorbar in log scale.') parser_heatmap.add_argument('-mp', action="store_true", help="Perform multiprocessing for faster computation.") parser_heatmap.add_argument('-show', action="store_true", help='Show the figure in the screen.') parser_heatmap.add_argument('-table', action="store_true", help='Store the tables of the figure in text format.') ################### Integration ########################################## parser_integration = subparsers.add_parser('integration', help='Provides some tools to deal with experimental matrix or other purposes.') parser_integration.add_argument('-ihtml', action="store_true", help='Integrate all the html files within the given directory and generate index.html for all plots.') parser_integration.add_argument('-l2m', help='Convert a given file list in txt format into a experimental matrix.') parser_integration.add_argument('-o', help='Define the folder of the output file.') ################### Parsing the arguments ################################ if len(sys.argv) == 1: parser.print_help() sys.exit(1) elif len(sys.argv) == 2: # retrieve subparsers from parser subparsers_actions = [action for action in parser._actions if isinstance(action, argparse._SubParsersAction)] # there will probably only be one subparser_action,but better save than sorry for subparsers_action in subparsers_actions: # get all subparsers and print help for choice, subparser in subparsers_action.choices.items(): if choice == sys.argv[1]: print("\nYou need more arguments.") print("\nSubparser '{}'".format(choice)) subparser.print_help() sys.exit(1) else: args = parser.parse_args() if not args.o: print("** Error: Please define the output directory (-o).") sys.exit(1) t0 = time.time() # Normalised output path args.o = os.path.normpath(os.path.join(dir,args.o)) check_dir(args.o) check_dir(os.path.join(args.o, args.t)) # Input parameters dictionary parameter = [] parameter.append("Time: " + datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")) parameter.append("User: "******"\nCommand:\n\t$ " + " ".join(sys.argv)) ################################################################################################# ##### Main ##################################################################################### ################################################################################################# ################### Projection test ########################################## if args.mode == 'projection': # Fetching reference and query EM print2(parameter, "\n############# Projection Test #############") print2(parameter, "\tReference: "+args.r) print2(parameter, "\tQuery: "+args.q) print2(parameter, "\tOutput directory: "+os.path.basename(args.o)) print2(parameter, "\tExperiment title: "+args.t) projection = Projection( args.r, args.q ) projection.group_refque(args.g) projection.colors( args.c, args.color ) if args.bg: projection.background(args.bg) if args.union: projection.ref_union() projection.projection_test(organism = args.organism) print2(parameter, "\tTaking intersect of references as the background. ") else: projection.projection_test(organism = args.organism) # generate pdf projection.plot(args.log) output(f=projection.fig, directory = args.o, folder = args.t, filename="projection_test", extra=plt.gci(),pdf=True,show=args.show) # generate html projection.gen_html(args.o, args.t, args=args) if args.table: projection.table(directory = args.o, folder = args.t) print("\nAll related files are saved in: "+ os.path.join(os.path.basename(args.o),args.t)) t1 = time.time() print2(parameter,"\nTotal running time is : " + str(datetime.timedelta(seconds=round(t1-t0)))) output_parameters(parameter, directory = args.o, folder = args.t, filename="parameters.txt") copy_em(em=args.r, directory=args.o, folder=args.t, filename="reference_experimental_matrix.txt") copy_em(em=args.q, directory=args.o, folder=args.t, filename="query_experimental_matrix.txt") list_all_index(path=args.o) ################### Intersect Test ########################################## if args.mode == 'intersect': print2(parameter, "\n############ Intersection Test ############") print2(parameter, "\tReference: "+args.r) print2(parameter, "\tQuery: "+args.q) print2(parameter, "\tOutput directory: "+os.path.basename(args.o)) print2(parameter, "\tExperiment title: "+args.t) # Fetching reference and query EM inter = Intersect(args.r,args.q, mode_count=args.m, organism=args.organism) # Setting background inter.background(args.bg) # Grouping inter.group_refque(args.g) # Extension if args.ex == 0: pass elif args.ex > 0: inter.extend_ref(args.ex) elif args.ex < 0: print("\n**** extension percentage(-ex) should be positive value, not negative.\n") sys.exit(1) inter.colors(args.c, args.color) inter.count_intersect(threshold=args.tc) # generate pdf inter.barplot(logt=args.log) output(f=inter.bar, directory = args.o, folder = args.t, filename="intersection_bar", extra=plt.gci(), pdf=True,show=args.show) inter.stackedbar() output(f=inter.sbar, directory = args.o, folder = args.t, filename="intersection_stackedbar", extra=plt.gci(), pdf=True,show=args.show) inter.barplot(logt=args.log, percentage=True) output(f=inter.bar, directory = args.o, folder = args.t, filename="intersection_barp", extra=plt.gci(), pdf=True,show=args.show) if args.stest > 0: inter.stest(repeat=args.stest,threshold=args.tc) # generate html inter.gen_html(args.o, args.t, align=50, args=args) t1 = time.time() print2(parameter, "\nAll related files are saved in: "+ os.path.join(os.path.basename(args.o),args.t)) print2(parameter,"\nTotal running time is : " + str(datetime.timedelta(seconds=round(t1-t0)))) output_parameters(parameter, directory = args.o, folder = args.t, filename="parameters.txt") copy_em(em=args.r, directory=args.o, folder=args.t, filename="reference_experimental_matrix.txt") copy_em(em=args.q, directory=args.o, folder=args.t, filename="query_experimental_matrix.txt") list_all_index(path=args.o) ################### Jaccard test ########################################## if args.mode == "jaccard": """Return the jaccard test of every possible comparisons between two ExperimentalMatrix. Method: The distribution of random jaccard index is calculated by randomizing query for given times. Then, we compare the real jaccard index to the distribution and formulate p-value as p-value = (# random jaccard > real jaccard)/(# random jaccard) """ print("\n############## Jaccard Test ###############") jaccard = Jaccard(args.reference,args.query) jaccard.group_refque(args.g) jaccard.colors(args.c, args.color) # jaccard test jaccard.jaccard_test(args.runtime, args.organism) parameter = parameter + jaccard.parameter t1 = time.time() # ploting and generate pdf jaccard.plot(logT=args.nlog) for i,f in enumerate(jaccard.fig): output(f=f, directory = args.o, folder = args.title, filename="jaccard_test"+str(i+1),extra=plt.gci(),pdf=True,show=args.show) # generate html jaccard.gen_html(args.o, args.title) if args.table: jaccard.table(directory = args.o, folder = args.title) print("\nAll related files are saved in: "+ os.path.join(dir,args.o,args.title)) print2(parameter,"\nTotal running time is : " + str(datetime.timedelta(seconds=round(t1-t0)))) output_parameters(parameter, directory = args.o, folder = args.title, filename="parameters.txt") copy_em(em=args.reference, directory=args.o, folder=args.title, filename="Reference_experimental_matrix.txt") copy_em(em=args.query, directory=args.o, folder=args.title, filename="Query_experimental_matrix.txt") list_all_index(path=args.o) ################### Combinatorial Test ########################################## if args.mode == 'combinatorial': print("\n############ Combinatorial Test ############") # Fetching reference and query EM comb = Combinatorial(args.reference,args.query, mode_count=args.m, organism=args.organism) # Setting background inter.background(args.bg) # Grouping inter.group_refque(args.g) # Extension if args.ex == 0: pass elif args.ex > 0: inter.extend_ref(args.ex) elif args.ex < 0: print("\n**** extension percentage(-ex) should be positive value, not negative.\n") sys.exit(1) # Combinatorial print2(parameter, "Generating all combinatorial regions for further analysis...") inter.combinatorial() inter.count_intersect(threshold=args.tc, frequency=True) # generate pdf inter.colors_comb() #inter.barplot(args.log) #output(f=inter.bar, directory = args.output, folder = args.title, filename="intersection_bar",extra=plt.gci(),pdf=True,show=args.show) #if args.stackedbar: #inter.colors(args.c, args.color,ref_que = "ref") inter.comb_stacked_plot() output(f=inter.sbar, directory = args.o, folder = args.title, filename="intersection_stackedbar",extra=plt.gci(),pdf=True,show=args.show) #if args.lineplot: # inter.comb_lineplot() if args.stest > 0: inter.stest(repeat=args.stest,threshold=args.tc) # generate html inter.gen_html_comb(args.o, args.title, align=50) parameter = parameter + inter.parameter t1 = time.time() print("\nAll related files are saved in: "+ os.path.join(dir,args.o,args.title)) print2(parameter,"\nTotal running time is : " + str(datetime.timedelta(seconds=round(t1-t0)))) output_parameters(parameter, directory = args.o, folder = args.title, filename="parameters.txt") copy_em(em=args.reference, directory=args.o, folder=args.title, filename="Reference_experimental_matrix.txt") copy_em(em=args.query, directory=args.o, folder=args.title, filename="Query_experimental_matrix.txt") list_all_index(path=args.o) ################### Boxplot ########################################## if args.mode == 'boxplot': print("\n################# Boxplot #################") boxplot = Boxplot(args.input, title=args.t, df=args.df) print2(parameter,"\nStep 1/5: Combining all regions") boxplot.combine_allregions() print2(parameter," " + str(len(boxplot.all_bed)) + " regions from all bed files are combined.") t1 = time.time() print2(parameter," --- finished in {0} secs\n".format(round(t1-t0))) # Coverage of reads on all_bed print2(parameter,"Step 2/5: Calculating coverage of each bam file on all regions") boxplot.bedCoverage() t2 = time.time() print2(parameter," --- finished in {0} (H:M:S)\n".format(datetime.timedelta(seconds=round(t2-t1)))) # Quantile normalization print2(parameter,"Step 3/5: Quantile normalization of all coverage table") if args.nqn: print2(parameter," No quantile normalization.") boxplot.norm_table = boxplot.all_table else: boxplot.quantile_normalization() t3 = time.time() print2(parameter," --- finished in {0} secs\n".format(round(t3-t2))) # Generate individual table for each bed print2(parameter,"Step 4/5: Constructing different tables for box plot") boxplot.tables_for_plot() if args.table: boxplot.print_plot_table(directory = args.o, folder = args.t) t4 = time.time() print2(parameter," --- finished in {0} secs\n".format(round(t4-t3))) # Plotting print2(parameter,"Step 5/5: Plotting") boxplot.group_tags(groupby=args.g, sortby=args.s, colorby=args.c) boxplot.group_data(directory = args.o, folder = args.t, log=args.nlog) boxplot.color_map(colorby=args.c, definedinEM=args.color) boxplot.plot(title=args.t, logT=args.nlog, sy=args.sy, ylim=args.ylim) #if args.table: boxplot.print_table(directory=args.output, folder=args.title) output(f=boxplot.fig, directory = args.o, folder = args.t, filename="boxplot",extra=plt.gci(),pdf=True,show=args.show) # HTML boxplot.gen_html(args.o, args.t, align = 50) t5 = time.time() print2(parameter," --- finished in {0} secs\n".format(round(t5-t4))) print2(parameter,"Total running time is: " + str(datetime.timedelta(seconds=round(t5-t0))) + " (H:M:S)\n") print("\nAll related files are saved in: "+ os.path.join(dir,args.o,args.t)) output_parameters(parameter, directory = args.o, folder = args.t, filename="parameters.txt") copy_em(em=args.input, directory=args.o, folder=args.t) list_all_index(path=args.o) ################### Lineplot ######################################### if args.mode == 'lineplot': if args.sy and args.sx: print("** Err: -sy and -sx cannot be used simutaneously.") sys.exit(1) print("\n################ Lineplot #################") # Read experimental matrix t0 = time.time() if "reads" not in (args.g, args.c, args.s): print("Please add 'reads' tag as one of grouping, sorting, or coloring argument.") sys.exit(1) if "regions" not in (args.g, args.c, args.s): print("Please add 'regions' tag as one of grouping, sorting, or coloring argument.") sys.exit(1) print2(parameter, "Parameters:\tExtend length:\t"+str(args.e)) print2(parameter, "\t\tRead size:\t"+str(args.rs)) print2(parameter, "\t\tBin size:\t"+str(args.bs)) print2(parameter, "\t\tStep size:\t"+str(args.ss)) print2(parameter, "\t\tCenter mode:\t"+str(args.center+"\n")) lineplot = Lineplot(EMpath=args.input, title=args.t, annotation=args.ga, organism=args.organism, center=args.center, extend=args.e, rs=args.rs, bs=args.bs, ss=args.ss, df=args.df) # Processing the regions by given parameters print2(parameter, "Step 1/3: Processing regions by given parameters") lineplot.relocate_bed() t1 = time.time() print2(parameter, " --- finished in {0} secs".format(str(round(t1-t0)))) if args.mp: print2(parameter, "\nStep 2/3: Calculating the coverage to all reads and averaging with multiprocessing ") else: print2(parameter, "\nStep 2/3: Calculating the coverage to all reads and averaging") lineplot.group_tags(groupby=args.g, sortby=args.s, colorby=args.c) lineplot.gen_cues() lineplot.coverage(sortby=args.s, mp=args.mp) t2 = time.time() print2(parameter, " --- finished in {0} (H:M:S)".format(str(datetime.timedelta(seconds=round(t2-t1))))) # Plotting print2(parameter, "\nStep 3/3: Plotting the lineplots") lineplot.colormap(colorby = args.c, definedinEM = args.color) lineplot.plot(groupby=args.g, colorby=args.c, output=args.o, printtable=args.table, sy=args.sy, sx=args.sx) output(f=lineplot.fig, directory = args.o, folder = args.t, filename="lineplot",extra=plt.gci(),pdf=True,show=args.show) lineplot.gen_html(args.o, args.t) t3 = time.time() print2(parameter, " --- finished in {0} secs".format(str(round(t3-t2)))) print2(parameter, "\nTotal running time is : " + str(datetime.timedelta(seconds=round(t3-t0))) + "(H:M:S)\n") print("\nAll related files are saved in: "+ os.path.join(dir,args.o,args.t)) output_parameters(parameter, directory = args.o, folder = args.t, filename="parameters.txt") copy_em(em=args.input, directory=args.o, folder=args.t) list_all_index(path=args.o) ################### Heatmap ########################################## if args.mode=='heatmap': print("\n################# Heatmap #################") # Most part of heat map are the same as lineplot, so it share the same class as lineplot # Read experimental matrix t0 = time.time() if "reads" not in (args.g, args.c, args.s): print("Please add 'reads' tag as one of grouping, sorting, or coloring argument.") sys.exit(1) if "regions" not in (args.g, args.c, args.s): print("Please add 'regions' tag as one of grouping, sorting, or coloring argument.") sys.exit(1) print2(parameter, "Parameters:\tExtend length:\t"+str(args.e)) print2(parameter, "\t\tRead size:\t"+str(args.rs)) print2(parameter, "\t\tBin size:\t"+str(args.bs)) print2(parameter, "\t\tStep size:\t"+str(args.ss)) print2(parameter, "\t\tCenter mode:\t"+str(args.center+"\n")) lineplot = Lineplot(EMpath=args.input, title=args.t, annotation=args.ga, organism=args.organism, center=args.center, extend=args.e, rs=args.rs, bs=args.bs, ss=args.ss, df=False) # Processing the regions by given parameters print2(parameter, "Step 1/4: Processing regions by given parameters") lineplot.relocate_bed() t1 = time.time() print2(parameter, " --- finished in {0} secs".format(str(round(t1-t0)))) if args.mp: print2(parameter, "\nStep 2/4: Calculating the coverage to all reads and averaging with multiprocessing ") else: print2(parameter, "\nStep 2/4: Calculating the coverage to all reads and averaging") lineplot.group_tags(groupby=args.g, sortby=args.s, colorby=args.c) lineplot.gen_cues() lineplot.coverage(sortby=args.s, heatmap=True, logt=args.log, mp=args.mp) t2 = time.time() print2(parameter, " --- finished in {0} (h:m:s)".format(str(datetime.timedelta(seconds=round(t2-t1))))) # Sorting print2(parameter, "\nStep 3/4: Sorting the data for heatmap") lineplot.hmsort(sort=args.sort) t3 = time.time() print2(parameter, " --- finished in {0} (h:m:s)".format(str(datetime.timedelta(seconds=round(t3-t2))))) # Plotting print2(parameter, "\nStep 4/4: Plotting the heatmap") lineplot.hmcmlist(colorby = args.c, definedinEM = args.color) lineplot.heatmap(args.log) for i, name in enumerate(lineplot.hmfiles): output(f=lineplot.figs[i], directory = args.o, folder = args.t, filename=name,pdf=True,show=args.show) lineplot.gen_htmlhm(args.o, args.t) t4 = time.time() print2(parameter, " --- finished in {0} secs".format(str(round(t4-t3)))) print2(parameter, "\nTotal running time is : " + str(datetime.timedelta(seconds=round(t4-t0))) + "(H:M:S)\n") print("\nAll related files are saved in: "+ os.path.join(dir,args.o,args.t)) output_parameters(parameter, directory = args.o, folder = args.t, filename="parameters.txt") copy_em(em=args.input, directory=args.o, folder=args.t) list_all_index(path=args.o)
def boxplot(self, dir, matrix, sig_region, truecounts, sig_boolean, ylabel, filename): """Generate the visualized plot""" tick_size = 8 label_size = 9 f, ax = plt.subplots(1, 1, dpi=300, figsize=(6, 4)) max_y = int(max([matrix.max()] + truecounts) * 1.1) + 1 min_y = max(int(matrix.min() * 0.9) - 1, 0) # Significant DBD rect = patches.Rectangle(xy=(1, 0), width=0.8, height=max_y, facecolor=sig_color, edgecolor="none", alpha=0.5, lw=None, label="Significant DBD") for i, r in enumerate(sig_boolean): if r: rect = patches.Rectangle(xy=(i + 0.6, min_y), width=0.8, height=max_y, facecolor=sig_color, edgecolor="none", alpha=0.5, lw=None, label="Significant DBD") ax.add_patch(rect) # Plotting bp = ax.boxplot(matrix.transpose(), notch=False, sym='o', vert=True, whis=1.5, positions=None, widths=None, patch_artist=True, bootstrap=None) z = 10 plt.setp(bp['boxes'], color=nontarget_color, alpha=1, edgecolor="none") plt.setp(bp['whiskers'], color='black', linestyle='-', linewidth=1, zorder=z, alpha=1) plt.setp(bp['fliers'], markerfacecolor='gray', color='white', alpha=0.3, markersize=1.8, zorder=z) plt.setp(bp['caps'], color='white', zorder=-1) plt.setp(bp['medians'], color='black', linewidth=1.5, zorder=z + 1) # Plot target regions plt.plot(range(1, len(self.rbss) + 1), truecounts, markerfacecolor=target_color, marker='o', markersize=5, linestyle='None', markeredgecolor="white", zorder=z + 5) ax.set_xlabel(self.rna_name + " DNA Binding Domains", fontsize=label_size) ax.set_ylabel(ylabel, fontsize=label_size, rotation=90) ax.set_ylim([min_y, max_y]) ax.yaxis.set_major_locator(MaxNLocator(integer=True)) ax.set_xticklabels([dbd.str_rna(pa=False) for dbd in self.rbss], rotation=35, ha="right", fontsize=tick_size) for tick in ax.yaxis.get_major_ticks(): tick.label.set_fontsize(tick_size) for spine in ['top', 'right']: ax.spines[spine].set_visible(False) ax.tick_params(axis='x', which='both', bottom='off', top='off', labelbottom='on') ax.tick_params(axis='y', which='both', left='on', right='off', labelbottom='off') # Legend dot_legend, = plt.plot([1, 1], color=target_color, marker='o', markersize=5, markeredgecolor="white", linestyle='None') bp_legend, = plt.plot([1, 1], color=nontarget_color, linewidth=6, alpha=1) ax.legend([dot_legend, bp_legend, rect], ["Target Regions", "Non-target regions", "Significant DBD"], bbox_to_anchor=(0., 1.02, 1., .102), loc=2, mode="expand", borderaxespad=0., prop={'size': 9}, ncol=3, numpoints=1) bp_legend.set_visible(False) dot_legend.set_visible(False) # f.tight_layout(pad=1.08, h_pad=None, w_pad=None) f.savefig(os.path.join(dir, filename + ".png"), facecolor='w', edgecolor='w', bbox_extra_artists=(plt.gci()), bbox_inches='tight', dpi=300) # PDF for tick in ax.xaxis.get_major_ticks(): tick.label.set_fontsize(12) for tick in ax.yaxis.get_major_ticks(): tick.label.set_fontsize(12) ax.xaxis.label.set_size(14) ax.yaxis.label.set_size(14) pp = PdfPages(os.path.join(dir, filename + '.pdf')) pp.savefig(f, bbox_extra_artists=(plt.gci()), bbox_inches='tight') pp.close()
# make the spectrogram plot ax1 = plt.subplot(311) plt.pcolor(t_spec, freqs, 10*np.log10(spec_PSDperBin)) # dB re: 1 uV plt.clim(25-5+np.array([-40, 0])) plt.xlim(t_sec[0], t_sec[-1]) if (t_lim_sec[2-1] != 0): plt.xlim(t_lim_sec) plt.ylim(f_lim_Hz) plt.xlabel('Time (sec)') plt.ylabel('Frequency (Hz)') plt.title(fname[12:]) # add annotation for FFT Parameters cl=plt.gci().get_clim(); ax1.text(0.025, 0.95, "NFFT = " + str(NFFT) + "\nfs = " + str(int(fs_Hz)) + " Hz\nClim = [" + str(cl[0]) + ", " + str(cl[1]) + "]", transform=ax1.transAxes, verticalalignment='top', horizontalalignment='left', backgroundcolor='w', size='smaller') # find spectra that are in our time span foo_spec = spec_PSDperBin bool_ind = np.zeros(t_spec.shape, dtype='bool') for lim_sec in alpha_lim_sec: bool_ind = bool_ind | ((t_spec >= lim_sec[0]) & (t_spec <= lim_sec[1])) foo_spec = foo_spec[:, bool_ind]
def lineplot(txp, rnalen, rnaname, dirp, sig_region, cut_off, log, ylabel, linelabel, filename, ac=None, showpa=False, exons=None): # Plotting f, ax = plt.subplots(1, 1, dpi=300, figsize=(6,4)) # Extract data points x = range(rnalen) #print(rnalen) if log: all_y = [1] * rnalen p_y = [1] * rnalen a_y = [1] * rnalen else: all_y = [0] * rnalen p_y = [0] * rnalen a_y = [0] * rnalen txp.remove_duplicates_by_dbs() for rd in txp: #print(str(rd.rna.initial), str(rd.rna.final)) if rd.rna.orientation == "P": for i in range(rd.rna.initial, rd.rna.final): p_y[i] += 1 all_y[i] += 1 if rd.rna.orientation == "A": for i in range(rd.rna.initial, rd.rna.final): a_y[i] += 1 all_y[i] += 1 # Log if log: all_y = numpy.log(all_y) p_y = numpy.log(p_y) a_y = numpy.log(a_y) max_y = max(all_y)+0.5 min_y = 1 ylabel += "(log10)" else: max_y = float(max(all_y) * 1.1) min_y = 0 if ac: min_y = float(max_y*(-0.09)) # Plotting for rbs in sig_region: rect = patches.Rectangle(xy=(rbs.initial,0), width=len(rbs), height=max_y, facecolor=sig_color, edgecolor="none", alpha=0.5, lw=None, label="Significant DBD") ax.add_patch(rect) lw = 1.5 if showpa: ax.plot(x, all_y, color=target_color, alpha=1, lw=lw, label="Parallel + Anti-parallel") ax.plot(x, p_y, color="purple", alpha=1, lw=lw, label="Parallel") ax.plot(x, a_y, color="dimgrey", alpha=.8, lw=lw, label="Anti-parallel") else: ax.plot(x, all_y, color="mediumblue", alpha=1, lw=lw, label=linelabel) # RNA accessbility if ac: n_value = read_ac(ac, cut_off, rnalen=rnalen) drawing = False for i in x: if n_value[i] > 0: if drawing: continue else: last_i = i drawing = True elif drawing: pac = ax.add_patch(patches.Rectangle((last_i, min_y), i-last_i, -min_y, hatch='///', fill=False, snap=False, linewidth=0, label="RNA accessibility")) drawing = False else: continue # Legend handles, labels = ax.get_legend_handles_labels() legend_h = [] legend_l = [] for uniqlabel in uniq(labels): legend_h.append(handles[labels.index(uniqlabel)]) legend_l.append(uniqlabel) ax.legend(legend_h, legend_l, bbox_to_anchor=(0., 1.02, 1., .102), loc=2, mode="expand", borderaxespad=0., prop={'size':9}, ncol=3) # XY axis ax.set_xlim(left=0, right=rnalen ) ax.set_ylim( [min_y, max_y] ) for tick in ax.xaxis.get_major_ticks(): tick.label.set_fontsize(9) for tick in ax.yaxis.get_major_ticks(): tick.label.set_fontsize(9) ax.set_xlabel(rnaname+" sequence (bp)", fontsize=9) ax.set_ylabel(ylabel,fontsize=9, rotation=90) if None: if exons and len(exons) > 1: w = 0 i = 0 h = (max_y - min_y)*0.02 for exon in exons: l = abs(exon[2] - exon[1]) #print([i,l,w]) #ax.axvline(x=w, color="gray", alpha=0.5, zorder=100) if i % 2 == 0: rect = matplotlib.patches.Rectangle((w,max_y-h),l,h, color="moccasin") else: rect = matplotlib.patches.Rectangle((w,max_y-h),l,h, color="gold") ax.add_patch(rect) i += 1 w += l ax.text(rnalen*0.01, max_y-2*h, "exon boundaries", fontsize=5, color='black') f.tight_layout(pad=1.08, h_pad=None, w_pad=None) f.savefig(os.path.join(dirp, filename), facecolor='w', edgecolor='w', bbox_extra_artists=(plt.gci()), bbox_inches='tight', dpi=300) # PDF for tick in ax.xaxis.get_major_ticks(): tick.label.set_fontsize(12) for tick in ax.yaxis.get_major_ticks(): tick.label.set_fontsize(12) ax.xaxis.label.set_size(14) ax.yaxis.label.set_size(14) ax.legend(legend_h, legend_l, bbox_to_anchor=(0., 1.02, 1., .102), loc=2, mode="expand", borderaxespad=0., prop={'size':12}, ncol=3) pp = PdfPages(os.path.splitext(os.path.join(dirp,filename))[0] +'.pdf') pp.savefig(f, bbox_inches='tight') # bbox_extra_artists=(plt.gci()), pp.close()
def handle(self, *args, **options): try: #DEG_STEP = 0.0005 # 0.1 deg longtitude = 9 km # 0.1 deg latitude = 11 km # wave glider speed : 0.9 m/s # advection speed 0.3 m/s # last coord 37.0598171042004 -122.460206988621 LAT_MAX = 37.15981 LON_MIN = -122.56020 LAT_MIN = 36.69 NUM_TICKS_PER_MIN = 6 plotInTicks = 6 WG_LAT_DEG_STEP_PER_MIN = 0.0299/NUM_TICKS_PER_MIN WG_LON_DEG_STEP_PER_MIN = 0.034/NUM_TICKS_PER_MIN collided = 0 STEP_DIST_MILE = 1.00662; #DEG_STEP = 0.005 pollWindowInSecs = 10; endDate = dt.now() startDate = endDate - timedelta(0,pollWindowInSecs) lastFew = VoteWP.objects.filter(date__gt=startDate, date__lt=endDate) latAvg = 0.0 lonAvg = 0.0 newLat = 0.0 newLon = 0.0 arr = numpy.ndarray(shape=(len(lastFew),2), dtype=float, order='F') ctr = 0; for vote_ in lastFew: latitude_ = vote_.latitude longitude_ = vote_.longitude if not (latitude_ < 1): arr[ctr,1] = latitude_ arr[ctr,0] = longitude_ ctr = ctr+1 else: print 'zero lat detected' winners = []; scoreMax = -1; centerMax = [] indMax = -1; for i in range(2,5): res, idx = kmeans2(arr,i) [c,d] = vq(arr, res) ua,uind=numpy.unique(idx,return_inverse=True) count=numpy.bincount(uind) maxCountInd = numpy.argmax(count) maxCount = max(count) center= [res[ua[maxCountInd],0],res[ua[maxCountInd],1]]; score = pow(maxCount,2)*(1/numpy.sum(d))*(1/sum(scipy.spatial.distance.pdist(res,'euclidean'))) if score > scoreMax: scoreMax = score centerMax = center indMax = i #res, idx = kmeans2(arr,indMax) # convert groups to rbg 3-tuples. #colors = ([([0,0,0],[0,1,1])[i] for i in idx]) # show sizes and colors. each color belongs in diff cluster. #pylab.scatter(arr[:,1],arr[:,0],s=20, c=colors) #plt.plot(res[1,1],res[1,0]) #pylab.savefig('/var/www/cinaps/jd/clust.png') lonAvg = centerMax[0] latAvg = centerMax[1] latestState = WaveGliderState.objects.latest('time') bearing_ = self.bearing(math.radians(latestState.latitude), math.radians(latestState.longitude),math.radians(latAvg),math.radians(lonAvg)) print 'bearing=' + str(bearing_) destPoint = VincentyDistance(STEP_DIST_MILE).destination(Point(latestState.latitude,latestState.longitude), bearing_) hour = 0 print destPoint print destPoint.latitude, destPoint.longitude newLat = destPoint.latitude newLon = destPoint.longitude #if not (self.testIfPointInSafeRegion(newLat,newLon)): # newLat = latestState.latitude # newLon = latestState.longitude # print 'here0' # collided = 0.1 #else: collided = 0.0 lon = 360.0+newLon; lonInd = int(math.floor((lon-237.2)/(1.3/131))) latInd = int(math.floor((newLat-35.6)/(1.7/171))) dataset = open_url("http://ourocean.jpl.nasa.gov:8080/thredds/dodsC/MBNowcast/mb_das_20120520_mean.nc") sst = dataset['temp'] tempMap = sst.array[hour,0,latInd,lonInd] tempVal = tempMap[0,0,0,0] salt = dataset['salt'] salMap = salt.array[hour,0,latInd,lonInd] salVal = salMap[0,0,0,0] vmin_,vmax_ = 0,800 trackWindowInSecs = 60*24; endDate = dt.now() startDate = endDate - timedelta(0,trackWindowInSecs) lastFewUpdates = WaveGliderState.objects.filter(time__gt=startDate, time__lt=endDate) lonVec = [] latVec = [] tempVec = [] salVec = [] chlVec = [] for wgUpdate in lastFewUpdates: lonVec = numpy.append(lonVec,wgUpdate.longitude) latVec = numpy.append(latVec, wgUpdate.latitude) tempVec = numpy.append(tempVec, wgUpdate.temp) salVec = numpy.append(salVec, wgUpdate.sal) chlVec = numpy.append(chlVec, wgUpdate.chl) plt.scatter(lonVec,latVec,10,chlVec,marker='s', edgecolors='none') plt.xlim([LON_MIN,-121.79]) plt.ylim([LAT_MIN,LAT_MAX]) fig = plt.gcf() a=fig.gca() a.set_frame_on(False) a.set_xticks([]); a.set_yticks([]) plt.axis('off') plt.clim(vmin_, vmax_) plt.savefig('science_data_layer_chl.png',transparent=True,pad_inches=0,bbox_inches='tight',frameon=False) os.system('cp /home/jd/science_data_layer_chl.png /var/www/cinaps/') plt.scatter(lonVec,latVec,10,salVec,marker='s', edgecolors='none') plt.xlim([LON_MIN,-121.79]) plt.ylim([LAT_MIN,LAT_MAX]) fig = plt.gcf() a=fig.gca() a.set_frame_on(False) a.set_xticks([]); a.set_yticks([]) plt.axis('off') salvmin_, salvmax_ = plt.gci().get_clim() plt.clim(salvmin_, salvmax_) plt.savefig('science_data_layer_sal.png',transparent=True,pad_inches=0,bbox_inches='tight',frameon=False) os.system('cp /home/jd/science_data_layer_sal.png /var/www/cinaps/') fig.clf() ax1 = fig.add_axes([0.05, 0.80, 0.9, 0.15]) cmap = mpl.cm.jet norm = mpl.colors.Normalize(vmin=salvmin_, vmax=salvmax_) cb1 = mpl.colorbar.ColorbarBase(ax1, cmap=cmap,norm=norm, orientation='horizontal') cbytick_obj = plt.getp(cb1.ax.axes, 'xticklabels') plt.setp(cbytick_obj, color='w') plt.setp(cbytick_obj, fontsize=18) cb1.set_label('Score') plt.savefig('/var/www/cinaps/jd/simoverlaycolorbarsal.png',transparent=True,pad_inches=0,bbox_inches='tight',frameon=False) fig.clf() #chlVal = -38.3894999141604 -0.700239885543149*tempVal + 1.62938943619475*salVal #doc = parser.parse('/home/jd/BatchGeo.kml').getroot() #data = doc.Document.Placemark.LineString.coordinates.text.split(' ') f = open('/home/jd/plumePoints.txt') data = [line.rstrip('\n') for line in f] numPoints = len(data) print 'start science field generation...' fig = plt.gcf() timestamp=calendar.timegm(dt.now().utctimetuple()) tick = (timestamp/10)%numPoints print tick ind1 = tick coord = data[ind1].split('\t') coord0 = data[0].split('\t') fieldLon = float(coord[2]) fieldLat = float(coord[1]) #fieldLon2 = -121.9462130707369 #fieldLat2 = 36.87829987329702 fieldLon2 = float(coord0[2]) fieldLat2 = float(coord0[1]) fig.clf() pi = math.pi widthScaler1 = 0.01/numPoints widthScaler2 = 0.05/numPoints sig = 0.01 sig1 = sig + ind1*widthScaler1 sig2 = sig + (numPoints-ind1)*widthScaler2 #sig2 = sig - (math.sin((((dt.now().second/60.0)*4*pi)-2*pi))*sig/2)+sig deltaLat = 0.00909 deltaLon = 0.0111 if ind1 % plotInTicks: x = numpy.arange(LON_MIN,-121.79,deltaLon) y = numpy.arange(LAT_MIN,LAT_MAX,deltaLat) X, Y = numpy.meshgrid(x, y) Z1 = mlab.bivariate_normal(X, Y, sig1,sig1 ,fieldLon,fieldLat) Z2 = mlab.bivariate_normal(X, Y, sig2, sig2,fieldLon2,fieldLat2) #CS1 = plt.contour(X, Y, Z1+Z2) CS2 = plt.pcolor(X, Y, Z1+Z2,alpha=0.5,shading='interp') #plt.clabel(CS1,inline=True,fontsize=10) plt.xlim([LON_MIN,-121.79]) plt.ylim([LAT_MIN,LAT_MAX]) #fig.patch.set_alpha(0.1) fig = plt.gcf() a=fig.gca() a.set_frame_on(False) a.set_xticks([]); a.set_yticks([]) plt.axis('off') plt.savefig('/var/www/cinaps/jd/simoverlay.png',transparent=True,pad_inches=0,bbox_inches='tight',frameon=False) #vmin_, vmax_ = plt.gci().get_clim() fig.clf() ax1 = fig.add_axes([0.05, 0.80, 0.9, 0.15]) cmap = mpl.cm.jet norm = mpl.colors.Normalize(vmin=vmin_, vmax=vmax_) cb1 = mpl.colorbar.ColorbarBase(ax1, cmap=cmap,norm=norm, orientation='horizontal') cbytick_obj = plt.getp(cb1.ax.axes, 'xticklabels') plt.setp(cbytick_obj, color='w') plt.setp(cbytick_obj, fontsize=18) cb1.set_label('Score') plt.savefig('/var/www/cinaps/jd/simoverlaycolorbarchl.png',transparent=True,pad_inches=0,bbox_inches='tight',frameon=False) fig.clf() chlVal = mlab.bivariate_normal(newLon, newLat, sig1,sig1 ,fieldLon,fieldLat) + mlab.bivariate_normal(newLon, newLat, sig2, sig2,fieldLon2,fieldLat2) print 'end science field generation...' print dt.now() now_ = dt.now() newWgState = WaveGliderState(time = now_, latitude = newLat,longitude = newLon, speed = 0, direction = bearing_,temp = tick+collided,sal = numpy.sum(chlVec)+chlVal,chl = chlVal) newWgState.save() ballot = BallotWP(time=endDate,latitude = latAvg,longitude=lonAvg ) ballot.save() plt.scatter(newWgState.longitude,newWgState.latitude,1,0,edgecolors='none') plt.xlim([-122.51918826855467,-121.75083194531248]) plt.ylim([36.61883405115106,36.97622643672235]) fig = plt.gcf() a=fig.gca() a.set_frame_on(False) a.set_xticks([]); a.set_yticks([]) plt.axis('off') plt.savefig('science_data_layer_none.png',transparent=True,pad_inches=0,bbox_inches='tight',frameon=False) os.system('cp /home/jd/science_data_layer_none.png /var/www/cinaps/') #fieldLat = 36.839438 #fieldLon = -122.096538 #fieldLat = newLat #fieldLon = newLon except VoteWP.DoesNotExist: raise CommandError('Error updating Wave Glider state') self.stdout.write('Succesfully updated Wave Glider state')
# Load inversion data gData = loadG('G_r512_k128_l4.h5', 1) # Apply the pBASEX algorithm out = pbasex(folded, gData, make_images=True, alpha=4.1e-5) # Plot some results plt.figure(figsize=(12,9)) for i, sample in enumerate(samples): plt.subplot(4,5,5*i+1) plt.imshow(raw[:,:,i]) plt.xticks([]) plt.yticks([]) plt.ylabel(sample) clim = plt.gci().get_clim() plt.clim(0,clim[1]) if i==0: plt.title('Raw Image') plt.subplot(4,5,5*i+2) plt.plot(out['E'], out['IE'][:,i], 'k') plt.gca().ticklabel_format(axis='y', style='sci', scilimits=(-2,2)) if i==3: plt.xlabel('Energy (eV)') plt.gca().twinx() plt.plot(out['E'], out['betas'][:,:,i], '.', markersize=5, alpha=0.6) if i==0: plt.text(-3, 3.5, 'counts per eV', size='small') plt.text(12, 3.5, 'beta', size='small') plt.text(3.5, 3.25, 'I(E), ', color='black', size='large') plt.text(6, 3.25, 'B2', color=u'#1f77b4', size='large')
coh_ave_plot = coh_ave_shfl_in_imag - coh_ave_shfl_in_cdtn psi_ave_plot = psi_ave_shfl_in_imag - psi_ave_shfl_in_cdtn elif plot_type == 'evok': coh_ave_plot = coh_ave_shfl_in_cdtn psi_ave_plot = psi_ave_shfl_in_cdtn h_fig, h_ax = plt.subplots(2,3, figsize=[8,6]) h_ax = h_ax.ravel() for i in range(6): plt.axes(h_ax[i]) pnp.SpectrogramPlot( coh_ave_plot[i,:,:], t_grid, freq, c_lim_style='diverge', t_lim=t_show) if i==0: plt.xlabel('t') plt.ylabel('freq') pnp.share_clim(h_ax) h_fig.colorbar(plt.gci(), ax=h_ax.tolist()) plt.suptitle('coherence {}, {}'.format(region_pair_focus, plot_type)) plt.savefig('./temp_figs/coherence_{}_all_session_{}_{}.png'.format(region_pair_focus, plot_type, block_type)) plt.savefig('./temp_figs/coherence_{}_all_session_{}_{}.pdf'.format(region_pair_focus,plot_type, block_type)) _, h_ax = plt.subplots(2,3, figsize=[8,6]) h_ax = h_ax.ravel() for i in range(6): plt.axes(h_ax[i]) pnp.SpectrogramPlot(psi_ave_plot[i,:,:], t_grid, freq, c_lim_style='diverge', t_lim=t_show) if i==0: plt.xlabel('t') plt.ylabel('freq') # plt.xlim([-0.1, 0.4]) pnp.share_clim(h_ax) h_fig.colorbar(plt.gci(), ax=h_ax.tolist())
def plot_mixture(mixture, i=0, j=1, center_style=dict(s=0.15), cmap='nipy_spectral', cutoff=0.0, ellipse_style=dict(alpha=0.3), solid_edge=True, visualize_weights=False): '''Plot the (Gaussian) components of the ``mixture`` density as one-sigma ellipses in the ``(i,j)`` plane. :param center_style: If a non-empty ``dict``, plot mean value with the style passed to ``scatter``. :param cmap: The color map to which components are mapped in order to choose their face color. It is unaffected by the ``cutoff``. The meaning depends on ``visualize_weights``. :param cutoff: Ignore components whose weight is below the ``cut off``. :param ellipse_style: Passed on to define the properties of the ``Ellipse``. :param solid_edge: Draw the edge of the ellipse as solid opaque line. :param visualize_weights: Colorize the components according to their weights if ``True``. One can do `plt.colorbar()` after this function and the bar allows to read off the weights. If ``False``, coloring is based on the component index and the total number of components. This option makes it easier to track components by assigning them the same color in subsequent calls to this function. ''' # imports inside the function because then "ImportError" is raised on # systems without 'matplotlib' only when 'plot_mixture' is called import numpy as np from matplotlib import pyplot as plt from matplotlib.patches import Ellipse from matplotlib.cm import get_cmap assert i >= 0 and j >= 0, 'Invalid submatrix specification (%d, %d)' % (i, j) assert i != j, 'Identical dimension given: i=j=%d' % i assert mixture.dim >= 2, '1D plot not supported' cmap = get_cmap(name=cmap) if visualize_weights: # colors according to weight renormalized_component_weights = np.array(mixture.weights) colors = [cmap(k) for k in renormalized_component_weights] else: # colors according to index colors = [cmap(k) for k in np.linspace(0, _max_color, len(mixture.components))] mask = mixture.weights >= cutoff # plot component means means = np.array([c.mu for c in mixture.components]) x_values = means.T[i] y_values = means.T[j] for k, w in enumerate(mixture.weights): # skip components by hand to retain consistent coloring if w < cutoff: continue cov = mixture.components[k].sigma submatrix = np.array([[cov[i,i], cov[i,j]], \ [cov[j,i], cov[j,j]]]) # for idea, check # 'Combining error ellipses' by John E. Davis correlation = np.array([[1.0, cov[i,j] / np.sqrt(cov[i,i] * cov[j,j])], [0.0, 1.0]]) correlation[1,0] = correlation[0,1] assert abs(correlation[0,1]) <= 1, 'Invalid component %d with correlation %g' % (k, correlation[0, 1]) ew, ev = np.linalg.eigh(submatrix) assert ew.min() > 0, 'Nonpositive eigenvalue in component %d: %s' % (k, ew) # rotation angle of major axis with x-axis if submatrix[0,0] == submatrix[1,1]: theta = np.sign(submatrix[0,1]) * np.pi / 4. else: theta = 0.5 * np.arctan( 2 * submatrix[0,1] / (submatrix[1,1] - submatrix[0,0])) # put larger eigen value on y'-axis height = np.sqrt(ew.max()) width = np.sqrt(ew.min()) # but change orientation of coordinates if the other is larger if submatrix[0,0] > submatrix[1,1]: height = np.sqrt(ew.min()) width = np.sqrt(ew.max()) # change sign to rotate in right direction angle = -theta * 180 / np.pi # copy keywords but override some ellipse_style_clone = dict(ellipse_style) # overwrite facecolor ellipse_style_clone['facecolor'] = colors[k] ax = plt.gca() # need full width/height e = Ellipse(xy=(x_values[k], y_values[k]), width=2*width, height=2*height, angle=angle, **ellipse_style_clone) ax.add_patch(e) if solid_edge: ellipse_style_clone['facecolor'] = 'none' ellipse_style_clone['edgecolor'] = colors[k] ellipse_style_clone['alpha'] = 1 ax.add_patch(Ellipse(xy=(x_values[k], y_values[k]), width=2*width, height=2*height, angle=angle, **ellipse_style_clone)) if center_style: plt.scatter(x_values[mask], y_values[mask], **center_style) if visualize_weights: # to enable plt.colorbar() mappable = plt.gci() mappable.set_array(mixture.weights) mappable.set_cmap(cmap)