def draw_bands(self, filtered_bands, spin_texture, **kwargs): if spin_texture["show"]: # Create the normalization for the colorscale of spin_moments. self._spin_texture_norm = Normalize(spin_texture["values"].min(), spin_texture["values"].max()) self._spin_texture_colorscale = spin_texture["colorscale"] super().draw_bands(filtered_bands=filtered_bands, spin_texture=spin_texture, **kwargs) if spin_texture["show"]: # Add the colorbar for spin texture. self.figure.colorbar(self._colorbar) # Add the ticks tick_vals = getattr(filtered_bands, "ticks", None) if tick_vals is not None: self.axes.set_xticks(tick_vals) tick_labels = getattr(filtered_bands, "ticklabels", None) if tick_labels is not None: self.axes.set_xticklabels(tick_labels) # Set the limits self.axes.set_xlim(*filtered_bands.k.values[[0, -1]]) self.axes.set_ylim(filtered_bands.min(), filtered_bands.max())
def create_cmap(values, colors): from matplotlib.pyplot import Normalize import matplotlib norm = Normalize(min(values), max(values)) tuples = list(zip(map(norm, values), colors)) cmap = matplotlib.colors.LinearSegmentedColormap.from_list("", tuples) return cmap, norm
def plot_frames_imshow( images, labels=None, nim=11, avg=50, interval=1, do1h=True, transpose=False, label_mapping=None, ): from matplotlib.colors import ListedColormap, LinearSegmentedColormap from matplotlib.pyplot import Normalize colors = ["red", "black", "green"] cmap = LinearSegmentedColormap.from_list("name", colors) if avg > images.shape[1]: avg = images.shape[1] rnge = range(0, np.maximum(images.shape[1] // avg, 1), interval) import pylab as plt plt.figure(figsize=[nim + 2, 16]) import matplotlib.gridspec as gridspec if not transpose: gs = gridspec.GridSpec(len(rnge), nim) else: gs = gridspec.GridSpec(nim, len(rnge)) plt.subplots_adjust(left=0, bottom=0, right=1, top=0.95, wspace=0.0, hspace=0.04) if labels is not None: if do1h: categories = labels.argmax(axis=1) else: categories = labels else: categories = range(len(images)) s = [] for j in range(nim): norm = Normalize(-0.1, 0.1) for e, i in enumerate(rnge): if not transpose: ax = plt.subplot(gs[e, j]) else: ax = plt.subplot(gs[j, e]) plt.imshow( images[j, i * avg : (i * avg + avg), 0, :, :].mean(axis=0).T - images[j, i * avg : (i * avg + avg), 1, :, :].mean(axis=0).T, cmap=cmap, norm=norm, ) plt.xticks([]) if i == 0 and label_mapping is not None: plt.title(label_mapping[int(categories[j])], fontsize=10) plt.yticks([]) s.append(images[j].sum())
def __init__(self, iterates, cmap_name=None): """ Iterate over objects returns tuple of object and color :param iterates: some iterable :param cmap_name: name of the color map """ self.iterates = iterates self.cmap = get_cmap(cmap_name) self.norm = Normalize()
def plot_optimized_network(network, blocking=True, save_plot=True): _title = 'Optimized network vs. non-optimized' figure(_title) graph = network.network_plot plot_layout = spring_layout(graph) balls = network.get_ball_distribution() print(network.ref_distribution) print(balls) min_val = 0 max_val = max([np_max(network.ref_distribution), np_max(balls)]) cmap = cm.Greys color_vals = cm.ScalarMappable(cmap=cmap, norm=Normalize(vmin=min_val, vmax=max_val)) color_vals._A = [] subplot(2, 1, 1) title('Initial network') colorbar(color_vals) draw_networkx_edges(graph, plot_layout, alpha=.3) draw_networkx_nodes(graph, plot_layout, node_size=100, edgecolors='k', node_color=network.ref_distribution, cmap=cmap, vmin=min_val, vmax=max_val) axis('off') # Disable axis subplot(2, 1, 2) title('Optimized network') colorbar(color_vals) draw_networkx_edges(graph, plot_layout, alpha=.3) draw_networkx_nodes(graph, plot_layout, node_size=100, edgecolors='k', node_color=balls, cmap=cmap, vmin=min_val, vmax=max_val) axis('off') draw() if save_plot: savefig('../results/optimized_network.png') show(block=blocking) # Open matplotlib window
def test_center_cmap(): """Test centering of colormap.""" from matplotlib.colors import LinearSegmentedColormap from matplotlib.pyplot import Normalize cmap = center_cmap(cm.get_cmap("RdBu"), -5, 10) assert isinstance(cmap, LinearSegmentedColormap) # get new colors for values -5 (red), 0 (white), and 10 (blue) new_colors = cmap(Normalize(-5, 10)([-5, 0, 10])) # get original colors for 0 (red), 0.5 (white), and 1 (blue) reference = cm.RdBu([0., 0.5, 1.]) assert_allclose(new_colors, reference) # new and old colors at 0.5 must be different assert not np.allclose(cmap(0.5), reference[1])
def plot_network(network, blocking=True, netx_plot=False, size=fig_size, weights=None, file_name=None, plot_edges=False, alph=.05): fig = figure(figsize=size) rcParams.update({ 'font.size': plot_font_size, 'mathtext.default': 'regular' }) ax = fig.gca() ax.axis('off') # Disable axis graph = network if netx_plot else network.network_plot plot_layout = kamada_kawai_layout(graph) cmap = cm.get_cmap('coolwarm') sizes, edge_colors, node_colors = 80, 'k', 'w' if weights is not None: sizes = [50 if weight == 0 else 80 for weight in weights] node_colors = weights min_val, max_val = min(weights), max(weights) if plot_edges: draw_networkx_edges(graph, plot_layout, alpha=alph) draw_networkx_nodes(graph, plot_layout, node_size=sizes, linewidths=.5, edgecolors='k', node_color=node_colors, cmap=cmap) draw() if weights is not None: plt = cm.ScalarMappable(cmap=cmap, norm=Normalize(vmin=0, vmax=1)) plt._A = [] colorbar(plt) if file_name is not None: savefig(file_name, bbox_inches='tight', pad_inches=0) show(block=blocking) # Open matplotlib window
def apply_color_map(colors, image): """ Applies the color specified by colors to the input image. Input: colors - list of colors in color map image - image to apply color map to with shape (n, n) Output: color_image - image with shape (n, n, 3) """ cmap = get_color_map(colors) norm = Normalize(vmin=0, vmax=len(colors)) color_image = cmap(norm(image))[:, :, 0:3] # drop alpha return color_image
def scatter_xyc(points, smooth=0, div=10, ax=None, **options): """ Draws a 2D graph (X,Y, color), the color is chosen based on a value *f(x,y)* The function requires :epkg:`matploblib` and :epkg:`scipy`. @param points (x,y, z=f(x,y) ) @param smooth applies n times a smoothing I * M (convolutional) @param div number of divisions for axis @param options others options: xlabel, ylabel, title, figsize (if ax is None) @return fig, ax (fig is None if ax was sent to the function) .. plot:: :include-source: import random def generate_gauss(x, y, sigma, N=1000): res = [] for i in range(N): u = random.gauss(0, 1) a = sigma * u + x b = sigma * random.gauss(0, 1) + y + u res.append((a, b)) return res def f(a, b): return (a ** 2 + b ** 2) ** 0.5 nuage1 = generate_gauss(0, 0, 3) nuage2 = generate_gauss(3, 4, 2) nuage = [(a, b, f(a, b)) for a, b in nuage1] + [(a, b, f(a, b)) for a, b in nuage2] import matplotlib.pyplot as plt from ensae_teaching_cs.helpers.matplotlib_helper_xyz import scatter_xyc fig, ax = scatter_xyc(nuage, title="example with random observations") plt.show() The error ``ValueError: Unknown projection '3d'`` is raised when the line ``from mpl_toolkits.mplot3d import Axes3D`` is missing. """ if ax is None: import matplotlib.pyplot as plt fig, ax = plt.subplots(figsize=options.get('figsize', None)) else: fig = None x = [_[0] for _ in points] y = [_[1] for _ in points] z = [_[2] for _ in points] tri = Triangulation(x, y) plt.tricontour(tri, z, 15, linewidths=0.5, colors='k') plt.tricontourf(tri, z, 15, cmap=plt.cm.rainbow, norm=Normalize(vmax=numpy.abs(z).max(), vmin=-numpy.abs(z).max())) plt.colorbar(ax=ax) ax.scatter(x, y, c='b', s=5, zorder=10) ax.set_xlim(min(x), max(x)) ax.set_ylim(min(y), max(y)) if "xlabel" in options: ax.set_xlabel(options["xlabel"]) if "ylabel" in options: ax.set_ylabel(options["ylabel"]) if "title" in options: ax.set_title(options["title"]) return fig, ax
def main(): try: import matplotlib except ImportError: sys.stderr.write("This script needs the 'matplotlib' library, which ") sys.stderr.write("was not found. Please install it." ) matplotlib.use('PDF') from matplotlib import pyplot # Matplotlib <1.5 uses normalize, so this block will be deprecated try: from matplotlib.pyplot import Normalize except ImportError: from matplotlib.pyplot import normalize as Normalize # **** Parse command line **** optParser = optparse.OptionParser( usage = "%prog [options] read_file", description= "This script take a file with high-throughput sequencing reads " + "(supported formats: SAM, Solexa _export.txt, FASTQ, Solexa " + "_sequence.txt) and performs a simply quality assessment by " + "producing plots showing the distribution of called bases and " + "base-call quality scores by position within the reads. The " + "plots are output as a PDF file.", epilog = "Written by Simon Anders ([email protected]), European Molecular Biology " + " Laboratory (EMBL). (c) 2010. Released under the terms of the GNU General " + " Public License v3. Part of the 'HTSeq' framework, version %s." % HTSeq.__version__ ) optParser.add_option( "-t", "--type", type="choice", dest="type", choices = ("sam", "bam", "solexa-export", "fastq", "solexa-fastq"), default = "sam", help="type of read_file (one of: sam [default], bam, " + "solexa-export, fastq, solexa-fastq)" ) optParser.add_option( "-o", "--outfile", type="string", dest="outfile", help="output filename (default is <read_file>.pdf)" ) optParser.add_option( "-r", "--readlength", type="int", dest="readlen", help="the maximum read length (when not specified, the script guesses from the file" ) optParser.add_option( "-g", "--gamma", type="float", dest="gamma", default = 0.3, help="the gamma factor for the contrast adjustment of the quality score plot" ) optParser.add_option( "-n", "--nosplit", action="store_true", dest="nosplit", help="do not split reads in unaligned and aligned ones" ) optParser.add_option( "-m", "--maxqual", type="int", dest="maxqual", default=41, help="the maximum quality score that appears in the data (default: 41)" ) if len( sys.argv ) == 1: optParser.print_help() sys.exit(1) (opts, args) = optParser.parse_args() if len( args ) != 1: sys.stderr.write( sys.argv[0] + ": Error: Please provide one argument (the read_file).\n" ) sys.stderr.write( " Call with '-h' to get usage information.\n" ) sys.exit( 1 ) readfilename = args[0] if opts.type == "sam": readfile = HTSeq.SAM_Reader( readfilename ) isAlnmntFile = True elif opts.type == "bam": readfile = HTSeq.BAM_Reader( readfilename ) isAlnmntFile = True elif opts.type == "solexa-export": readfile = HTSeq.SolexaExportReader( readfilename ) isAlnmntFile = True elif opts.type == "fastq": readfile = HTSeq.FastqReader( readfilename ) isAlnmntFile = False elif opts.type == "solexa-fastq": readfile = HTSeq.FastqReader( readfilename, "solexa" ) isAlnmntFile = False else: sys.error( "Oops." ) twoColumns = isAlnmntFile and not opts.nosplit if opts.outfile is None: outfilename = os.path.basename( readfilename ) + ".pdf" else: outfilename = opts.outfile # **** Get read length **** if opts.readlen is not None: readlen = opts.readlen else: readlen = 0 if isAlnmntFile: reads = ( a.read for a in readfile ) else: reads = readfile for r in islice( reads, 10000 ): if len( r ) > readlen: readlen = len( r ) max_qual = opts.maxqual gamma = opts.gamma # **** Initialize count arrays **** base_arr_U = numpy.zeros( ( readlen, 5 ), numpy.int ) qual_arr_U = numpy.zeros( ( readlen, max_qual+1 ), numpy.int ) if twoColumns: base_arr_A = numpy.zeros( ( readlen, 5 ), numpy.int ) qual_arr_A = numpy.zeros( ( readlen, max_qual+1 ), numpy.int ) # **** Main counting loop **** i = 0 try: for a in readfile: if isAlnmntFile: r = a.read else: r = a if twoColumns and (isAlnmntFile and a.aligned): r.add_bases_to_count_array( base_arr_A ) r.add_qual_to_count_array( qual_arr_A ) else: r.add_bases_to_count_array( base_arr_U ) r.add_qual_to_count_array( qual_arr_U ) i += 1 if (i % 200000) == 0: print(i, "reads processed") except: sys.stderr.write( "Error occured in: %s\n" % readfile.get_line_number_string() ) raise print(i, "reads processed") # **** Normalize result **** def norm_by_pos( arr ): arr = numpy.array( arr, numpy.float ) arr_n = ( arr.T / arr.sum( 1 ) ).T arr_n[ arr == 0 ] = 0 return arr_n def norm_by_start( arr ): arr = numpy.array( arr, numpy.float ) arr_n = ( arr.T / arr.sum( 1 )[ 0 ] ).T arr_n[ arr == 0 ] = 0 return arr_n base_arr_U_n = norm_by_pos( base_arr_U ) qual_arr_U_n = norm_by_start( qual_arr_U ) nreads_U = base_arr_U[0,:].sum() if twoColumns: base_arr_A_n = norm_by_pos( base_arr_A ) qual_arr_A_n = norm_by_start( qual_arr_A ) nreads_A = base_arr_A[0,:].sum() # **** Make plot **** def plot_bases( arr ): xg = numpy.arange( readlen ) pyplot.plot( xg, arr[ : , 0 ], marker='.', color='red') pyplot.plot( xg, arr[ : , 1 ], marker='.', color='darkgreen') pyplot.plot( xg, arr[ : , 2 ], marker='.',color='lightgreen') pyplot.plot( xg, arr[ : , 3 ], marker='.',color='orange') pyplot.plot( xg, arr[ : , 4 ], marker='.',color='grey') pyplot.axis( (0, readlen-1, 0, 1 ) ) pyplot.text( readlen*.70, .9, "A", color="red" ) pyplot.text( readlen*.75, .9, "C", color="darkgreen" ) pyplot.text( readlen*.80, .9, "G", color="lightgreen" ) pyplot.text( readlen*.85, .9, "T", color="orange" ) pyplot.text( readlen*.90, .9, "N", color="grey" ) pyplot.figure() pyplot.subplots_adjust( top=.85 ) pyplot.suptitle( os.path.basename(readfilename), fontweight='bold' ) if twoColumns: pyplot.subplot( 221 ) plot_bases( base_arr_U_n ) pyplot.ylabel( "proportion of base" ) pyplot.title( "non-aligned reads\n%.0f%% (%.3f million)" % ( 100. * nreads_U / (nreads_U+nreads_A), nreads_U / 1e6 ) ) pyplot.subplot( 222 ) plot_bases( base_arr_A_n ) pyplot.title( "aligned reads\n%.0f%% (%.3f million)" % ( 100. * nreads_A / (nreads_U+nreads_A), nreads_A / 1e6 ) ) pyplot.subplot( 223 ) pyplot.pcolor( qual_arr_U_n.T ** gamma, cmap=pyplot.cm.Greens, norm=Normalize( 0, 1 ) ) pyplot.axis( (0, readlen-1, 0, max_qual+1 ) ) pyplot.xlabel( "position in read" ) pyplot.ylabel( "base-call quality score" ) pyplot.subplot( 224 ) pyplot.pcolor( qual_arr_A_n.T ** gamma, cmap=pyplot.cm.Greens, norm=Normalize( 0, 1 ) ) pyplot.axis( (0, readlen-1, 0, max_qual+1 ) ) pyplot.xlabel( "position in read" ) else: pyplot.subplot( 211 ) plot_bases( base_arr_U_n ) pyplot.ylabel( "proportion of base" ) pyplot.title( "%.3f million reads" % ( nreads_U / 1e6 ) ) pyplot.subplot( 212 ) pyplot.pcolor( qual_arr_U_n.T ** gamma, cmap=pyplot.cm.Greens, norm=Normalize( 0, 1 ) ) pyplot.axis( (0, readlen-1, 0, max_qual+1 ) ) pyplot.xlabel( "position in read" ) pyplot.ylabel( "base-call quality score" ) pyplot.savefig( outfilename )
def plot( result, readfilename, outfile, max_qual, gamma, primary_only=False, ): def plot_bases(arr, ax): xg = np.arange(readlen) ax.plot(xg, arr[:, 0], marker='.', color='red') ax.plot(xg, arr[:, 1], marker='.', color='darkgreen') ax.plot(xg, arr[:, 2], marker='.', color='lightgreen') ax.plot(xg, arr[:, 3], marker='.', color='orange') ax.plot(xg, arr[:, 4], marker='.', color='grey') ax.set_xlim(0, readlen-1) ax.set_ylim(0, 1) ax.text(readlen*.70, .9, "A", color="red") ax.text(readlen*.75, .9, "C", color="darkgreen") ax.text(readlen*.80, .9, "G", color="lightgreen") ax.text(readlen*.85, .9, "T", color="orange") ax.text(readlen*.90, .9, "N", color="grey") if outfile is None: outfilename = os.path.basename(readfilename) + ".pdf" else: outfilename = outfile isAlnmntFile = result['isAlnmntFile'] readlen = result['readlen'] twoColumns = result['twoColumns'] base_arr_U_n = result['base_arr_U_n'] qual_arr_U_n = result['qual_arr_U_n'] nreads_U = result['nreads_U'] if twoColumns: base_arr_A_n = result['base_arr_A_n'] qual_arr_A_n = result['qual_arr_A_n'] nreads_A = result['nreads_A'] cur_backend = matplotlib.get_backend() try: matplotlib.use('PDF') fig = plt.figure() fig.subplots_adjust(top=.85) fig.suptitle(os.path.basename(readfilename), fontweight='bold') if twoColumns: ax = fig.add_subplot(221) plot_bases(base_arr_U_n, ax) ax.set_ylabel("proportion of base") ax.set_title( "non-aligned reads\n{:.0%} ({:.4f} million)".format( 1.0 * nreads_U / (nreads_U+nreads_A), 1.0 * nreads_U / 1e6, )) ax2 = fig.add_subplot(222) plot_bases(base_arr_A_n, ax2) ax2.set_title( "{:}\n{:.0%} ({:.4f} million)".format( 'aligned reads' if primary_only else 'alignments', 1.0 * nreads_A / (nreads_U+nreads_A), 1.0 * nreads_A / 1e6, )) ax3 = fig.add_subplot(223) ax3.pcolor( qual_arr_U_n.T ** gamma, cmap=plt.cm.Greens, norm=Normalize(0, 1)) ax3.set_xlim(0, readlen-1) ax3.set_ylim(0, max_qual+1) ax3.set_xlabel("position in read") ax3.set_ylabel("base-call quality score") ax4 = fig.add_subplot(224) ax4.pcolor( qual_arr_A_n.T ** gamma, cmap=plt.cm.Greens, norm=Normalize(0, 1)) ax4.set_xlim(0, readlen-1) ax4.set_ylim(0, max_qual+1) ax4.set_xlabel("position in read") else: ax = fig.add_subplot(211) plot_bases(base_arr_U_n, ax) ax.set_ylabel("proportion of base") ax.set_title("{:.3f} million {:}".format( 1.0 * nreads_U / 1e6, 'reads' if (not isAlnmntFile) or primary_only else 'alignments', )) ax2 = fig.add_subplot(212) ax2.pcolor( qual_arr_U_n.T ** gamma, cmap=plt.cm.Greens, norm=Normalize(0, 1)) ax2.set_xlim(0, readlen-1) ax2.set_ylim(0, max_qual+1) ax2.set_xlabel("position in read") ax2.set_ylabel("base-call quality score") fig.savefig(outfilename) finally: matplotlib.use(cur_backend)
def draw_dendrogram(self, ax, pairs, values, labels, lw=20., alpha=0.4, cmap='viridis'): try: from matplotlib import collections as mc from matplotlib.pyplot import Arrow from matplotlib.pyplot import Normalize from matplotlib.pyplot import cm except ImportError: raise ImportError('You must install the matplotlib library to plot the minimum spanning tree.') min_index, max_index = min(pairs), max(pairs) if min_index < 0: raise ValueError('Indices should be non-negative') size = int(len(pairs) / 2 + 1) union_size = size if max_index > union_size - 1: union_size = max_index + 1 union_size += 2 # we will create Union Find as usual uf, sz = np.zeros(2 * union_size, dtype=int), np.ones(union_size) next_label = union_size + 1 # also we need links l, r = np.arange(0, 2*union_size), np.arange(0, 2*union_size) next_label = union_size + 1 for j in range(0, size - 1): a, b = pairs[2 * j], pairs[2 * j + 1] # we will stack first cluster on the left of second aa = a while aa != r[aa]: aa = r[aa] bb = b while bb != l[bb]: bb = l[bb] l[bb] = aa r[aa] = bb # linking aa = a while aa != l[aa]: aa = l[aa] bb = b while bb != r[bb]: bb = r[bb] l[next_label] = aa # marking the borders r[next_label] = bb aa, bb = self.fast_find(uf, a), self.fast_find(uf, b) uf[aa] = uf[bb] = next_label # i = next_label - union_size # a2 = (uf[a] != 0) * (aa - union_size) # b2 = (uf[b] != 0) * (bb - union_size) # na, nb = sz[a2], sz[b2] # sz[i] = na + nb next_label += 1 x_arr = self.arrange_nodes_on_x_axis(uf, union_size, l, r, 200.) norm = len(np.unique(pairs)) sm = cm.ScalarMappable(cmap=cmap, norm=Normalize(0, norm)) sm.set_array(norm) colors = self.get_dendro_colors(labels) heights = {} uf.fill(0) next_label = union_size + 1 for j in range(0, size - 1): v = np.log2(1. + values[j]) # logarithm heights[next_label] = v a, b = pairs[2 * j], pairs[2 * j + 1] # i = next_label - union_size aa, bb = self.fast_find(uf, a), self.fast_find(uf, b) x_arr[next_label] = (x_arr[r[aa]] + x_arr[l[bb]])/2. uf[aa] = uf[bb] = next_label next_label += 1 # a = (uf[a] != 0) * (aa - union_size) # b = (uf[b] != 0) * (bb - union_size) # na, nb = sz[a], sz[b] # sz[i] = na + nb ha, hb = 0, 0 xa, xb = x_arr[aa], x_arr[bb] if aa in heights: ha = heights[aa] if bb in heights: hb = heights[bb] c = 'gray' if labels[a] == labels[b] and labels[a] > 0: c = colors[labels[a]] ax.plot([xa, xa], [ha, v], color=c) ax.plot([xb, xb], [hb, v], color=c) ax.plot([xa, xb], [v, v], color=c) ax.set_xticks([]) for side in ('right', 'top', 'bottom'): ax.spines[side].set_visible(False) ax.set_ylabel('distance') # line_collection.set_array(self._mst[:, 2].T) return ax