def testActiveLegend(self): import mpld3 from mpld3 import plugins from mpld3.utils import get_id import numpy as np import collections import matplotlib.pyplot as plt N_paths = 5 N_steps = 100 x = np.linspace(0, 10, 100) y = 0.1 * (np.random.random((N_paths, N_steps)) - 0.5) y = y.cumsum(1) fig = plt.figure(figsize=(16, 7)) # 8 inches wide by 6 inches tall ax = fig.add_subplot(2, 2, 1) # fig, ax = plt.subplots() labels = ["a", "b", "c", "d", "e"] line_collections = ax.plot(x, y.T, lw=4, alpha=0.2) interactive_legend = plugins.InteractiveLegendPlugin( line_collections, labels) plugins.connect(fig, interactive_legend) mpld3.show()
def plot_by_mpld3(dataframe,figsize=(12,6),marker='o',grid=True, alpha_ax=0.3,alpha_plot=0.4,alpha_unsel=0.3,alpha_over=1.5, title=None,xlabel=None,ylabel=None,mode="display",file=None): ## DataFrame 데이터를 이용하여 웹용 D3 chart 스크립트 생성 # plot line + confidence interval fig, ax = plt.subplots(figsize=figsize) ax.grid(grid, alpha=alpha_ax) for key, val in dataframe.iteritems(): l, = ax.plot(val.index, val.values, label=key, marker=marker) ax.plot(val.index,val.values, color=l.get_color(), alpha=alpha_plot) # define interactive legend handles, labels = ax.get_legend_handles_labels() # return lines and labels interactive_legend = plugins.InteractiveLegendPlugin(handles,labels, alpha_unsel=alpha_unsel, alpha_over=alpha_over, start_visible=True) plugins.connect(fig, interactive_legend) if xlabel: ax.set_xlabel(xlabel) if ylabel: ax.set_ylabel(ylabel) if title: ax.set_title(title, size=len(title)+5) ## mode if mode == 'html': # return html script return mpld3.fig_to_html(fig) elif mode == 'save' and file: # save file mpld3.save_html(fig,file) else: # display chart #mpld3.enable_notebook() return mpld3.display()
def create_plot(self, x, y1, y2): fig, ax = plt.subplots() y1, y1_b, y1_e = trim_list(y1) y2, y2_b, y2_e = trim_list(y2) x_dates = map(string2date, x) ax.set_xlim(left=min((x_dates[y1_b:-y1_e][0], x_dates[y2_b:-y2_e][0])), right=max( (x_dates[y1_b:-y1_e][-1], x_dates[y2_b:-y2_e][-1]))) co = list() co.append(ax.plot(x_dates[y1_b:-y1_e], y1, 'b', label='One')) co.append(ax.plot(x_dates[y2_b:-y2_e], y2, 'r', label='Two')) handles, labels = ax.get_legend_handles_labels( ) # return lines and labels interactive_legend = plugins.InteractiveLegendPlugin( zip(handles, co), labels, alpha_unsel=0.5, alpha_over=1.5, start_visible=True) plugins.connect(fig, interactive_legend) ax.fill_between(x_dates[y1_b:-y1_e], y1, facecolors='blue', alpha=0.5) ax.fill_between(x_dates[y2_b:-y2_e], y2, facecolors='red', alpha=0.5) ax.set_title(self.title) plt.subplots_adjust(right=.8) fig.set_size_inches(10, 8, forward=True) return mpld3.fig_to_html(fig)
def get_plot(date=None, output='html'): date = date or dt.datetime.now() fig, ax = plt.subplots(figsize=(10, 4)) plot_db_data(ax, date) plot_forecast(ax, date) plot_grid(fig, ax) handles, labels = ax.get_legend_handles_labels() if output == 'html': interactive_legend = plugins.InteractiveLegendPlugin(handles, labels) plugins.connect(fig, interactive_legend) fig.subplots_adjust(right=0.7) plot_html = mpld3.fig_to_html(fig, template_type='general') return plot_html else: ax.legend(handles, labels) plt.savefig('./static/graph/graph.png') plt.close() f = open('./static/graph/graph.png', 'rb') return f
def __call__(self, plot, view): if not self._applies(plot, view): return fig = plot.handles['fig'] if 'legend' in plot.handles: plot.handles['legend'].set_visible(False) line_segments, labels = [], [] keys = view.keys() for idx, subplot in enumerate(plot.subplots.values()): if isinstance(subplot, PointPlot): line_segments.append(subplot.handles['paths']) if isinstance(view, NdOverlay): labels.append(str(keys[idx])) else: labels.append(subplot.hmap.last.label) elif isinstance(subplot, CurvePlot): line_segments.append(subplot.handles['line_segment']) if isinstance(view, NdOverlay): labels.append(str(keys[idx])) else: labels.append(subplot.hmap.last.label) tooltip = plugins.InteractiveLegendPlugin(line_segments, labels, alpha_sel=self.alpha_sel, alpha_unsel=self.alpha_unsel) plugins.connect(fig, tooltip)
def allTrend(self): self.loadAlldata() fig = plt.figure(figsize=(17, 13)) # 8 inches wide by 6 inches tall ax = fig.add_subplot(2, 2, 1) ax.set_ylabel('hours') ax.set_xlabel('days in a month') ax.set_ylim(0, 12) ax.set_title('time trend for different activity') labels = [ "light activity", "fairly activity", "very activity", 'very not productive', 'not productive', 'neutural', 'productive', 'very productive', 'awake', 'REM', 'light sleep', 'deep sleep' ] colors = [ 'lime', 'green', 'darkgreen', 'gray', 'brown', 'blue', 'darkblue', 'navy', 'coral', 'violet', 'plum', 'purple' ] line_collections = [] activityvalue = np.array(list(self.activity.values())) for i in range(3): y1 = activityvalue[:, i] / 60 x1 = np.array(range( len(y1))) # light activity, fairly activity, very activity l1 = ax.plot(x1, y1, lw=3, alpha=0.4, c=colors[i], label=labels[i]) line_collections.append(l1) provalues = np.array(list(self.desk.values())) for i in range(5): y1 = provalues[:, i] x1 = np.array(range(len(y1))) # l1 = ax.plot(x1, y1, lw=3, alpha=0.4, c=colors[3 + i], label=labels[3 + i]) line_collections.append(l1) sleepvalues = np.array(list(self.sleep.values())) for i in range(4): y1 = sleepvalues[:, i] / 60 x1 = np.array(range(len(y1))) # l1 = ax.plot(x1, y1, lw=4, alpha=0.4, c=colors[8 + i], label=labels[8 + i]) line_collections.append(l1) plugins.connect( fig, plugins.InteractiveLegendPlugin(line_collections, labels)) # mpld3.show() mpld3.save_html(fig, 'trend.html')
def plot_norm_cart_interacive_el(el_co, fname, save_dir): plt.ioff() #turns plot off el_co = el_co.convert_objects(convert_numeric=True) #normalize normalised_el_co, _ = Sector.normalise2("", el_co, el_co) #Get Freq list of column headers headers_el_co = list(el_co.dtypes.index) #Create plot fig, ax = plt.subplots(figsize=(12, 7)) fig.subplots_adjust(right=.8) labels = headers_el_co line_collections = ax.plot(normalised_el_co, lw=1.5, alpha=0.9) interactive_legend = plugins.InteractiveLegendPlugin(line_collections, labels, alpha_unsel=0.1, alpha_over=1.5, start_visible=False) plugins.connect(fig, interactive_legend) ########################################################################### # Figure Settings #Set axis parameters ax.grid(alpha=0.25) ax.set_ylim([-40, 0.5]) ax.set_xlim([0, 360]) x_tick_spacing = 20 y_tick_spacing = 3 ax.xaxis.set_major_locator(ticker.MultipleLocator(x_tick_spacing)) ax.yaxis.set_major_locator(ticker.MultipleLocator(y_tick_spacing)) #Set Plot title & axis titles ax.set_ylabel('dBi') ax.set_xlabel('Angle') ax.set_ylim([-40, 0.5]) ax.set_xlim([0, 360]) ax.set_title(fname) #Save the figure as a html mpld3.save_html(fig, save_dir + fname + ".html") plt.close('all') plt.ion()
def make_mpld3_position_plot(output_path, input_paths): fig,ax = make_agent_positions_figure(input_paths) handles, labels = ax.get_legend_handles_labels() # return lines and labels interactive_legend = plugins.InteractiveLegendPlugin(zip(handles, ax.lines), labels, alpha_unsel=.1, alpha_over=1.5, start_visible=True) plugins.connect(fig, interactive_legend) html = mpld3.fig_to_html(fig) with open(output_path, "w") as html_file: html_file.write(html)
def create_plot(): fig, ax = plt.subplots() x = np.linspace(0, 10, 100) l1 = ax.plot(x, np.sin(x), label='sin', lw=3, alpha=0.2) l2 = ax.plot(x, np.cos(x), label='cos', lw=3, alpha=0.2) l3 = ax.plot(x[::5], 0.5 * np.sin(x[::5] + 2), 'ob', label='dots', alpha=0.2) labels = ['sin', 'cos', 'dots'] interactive_legend = plugins.InteractiveLegendPlugin([l1, l2, l3], labels) plugins.connect(fig, interactive_legend) ax.set_title("Interactive legend test", size=20) return fig
def testInterLegend(): import matplotlib.pyplot as plt import numpy as np import pandas as pd import mpld3 from mpld3 import plugins np.random.seed(9615) # generate df N = 100 df = pd.DataFrame( (.1 * (np.random.random((N, 5)) - .5)).cumsum(0), columns=['a', 'b', 'c', 'd', 'e'], ) # plot line + confidence interval fig, ax = plt.subplots() ax.grid(True, alpha=0.3) for key, val in df.iteritems(): l, = ax.plot(val.index, val.values, label=key) ax.fill_between(val.index, val.values * .5, val.values * 1.5, color=l.get_color(), alpha=.4) # define interactive legend handles, labels = ax.get_legend_handles_labels() # return lines and labels interactive_legend = plugins.InteractiveLegendPlugin(zip( handles, ax.collections), labels, alpha_unsel=0.5, alpha_over=1.5, start_visible=True) plugins.connect(fig, interactive_legend) ax.set_xlabel('x') ax.set_ylabel('y') ax.set_title('Interactive legend', size=20) mpld3.show()
def genRollGraph(self): fig, ax = plt.subplots() labels = ["Fast-Roll", "Ramp-Down", "Ramp-Up", "Slow-Roll"] line_collections = ax.plot(self.X_roll, self.y_roll, lw=4, alpha=0.2) interactive_legend = plugins.InteractiveLegendPlugin( line_collections, labels) plugins.connect(fig, interactive_legend) fig.set_size_inches(14, 6) plt.subplots_adjust(right=0.8) ax.set_xlabel("Time Segment") ax.set_ylabel("Confidence Level") ax.set_title("Turbine Roll", size=24) output = mpld3.fig_to_html(fig, d3_url='assets/js/d3.v3.min.js', mpld3_url='assets/js/mpld3.js') with open('rollGraph.html', 'w') as f: f.write(output) plt.savefig('rollGraph.png') plt.close()
def plot(self): """Generate the plot and connects the plugins for interaction but do not show it""" self._setup_axes() self._plot_grid() self._plot_road() self._plot_sectors() # We do not care about indivual segments. But plotting them might help during debugging # self._plot_road_segments() self._plot_car() # Initialize the plot by visualizing nothign more than the grid. The road geometry will be there, as I cannot # hide it for the moment.... visible_elements = [False] * len(list(self.labels_and_handlers.keys())) visible_elements[0] = True # Visualize the grid only by default # Configure the plugin that shows the interactive legend interactive_legend = plugins.InteractiveLegendPlugin( self.labels_and_handlers.values(), list(self.labels_and_handlers.keys()), # Setting alpha to 0.0 makes lines disappear but not patches alpha_unsel=0.0, alpha_over=1.5, start_visible=visible_elements, font_size=14, legend_offset=(-10, 0)) # Configure the plugin that export road metadata as global variable export_road_metadata = ExportRoadMetadataPlugin( self._collect_road_metadata()) plugins.connect(self.fig, interactive_legend, export_road_metadata)
def genErrorGraph(self): fig, ax = plt.subplots() labels = [ "Bearing Rub", "Preload", "Safe", "Weight Unbalance", ] line_collections = ax.plot(self.X_error, self.y_error, lw=4, alpha=0.2) interactive_legend = plugins.InteractiveLegendPlugin( line_collections, labels) plugins.connect(fig, interactive_legend) fig.set_size_inches(14, 6) plt.subplots_adjust(right=0.8) ax.set_xlabel("Time Segment") ax.set_ylabel("Confidence Level") ax.set_title("Turbine Error Modes", size=24) output = mpld3.fig_to_html(fig, d3_url='assets/js/d3.v3.min.js', mpld3_url='assets/js/mpld3.js') with open('errorGraph.html', 'w') as f: f.write(output) plt.savefig('errorGraph.png') plt.close()
def __generatehtml(self, fig): i = 0 for ax in fig.get_axes(): plugins.connect( fig, plugins.InteractiveLegendPlugin( plot_elements=ax.get_lines(), labels=[str(x) for x in ax.get_legend().get_texts()], ax=ax, alpha_unsel=0.0, alpha_over=1.5)) i += 1 for line in ax.get_lines(): line.set_ydata( [x if x is not None else 0 for x in line.get_ydata()]) plugins.connect( fig, plugins.PointLabelTooltip( points=line, labels=[str(y) for y in line.get_ydata()], hoffset=10, voffset=10)) return mpld3.fig_to_html(fig)
def four_group_plot(csv_file, x_col, y_col, group1_col, group2_col, group3_col, show_only_col, show_only_col_flag=True): data = pd.read_csv(csv_file) data_group1 = data.groupby(group1_col) group2_labels = data[group2_col] fig, ax = plt.subplots() ax.margins(0.05) group1_marker_type = ['o', 's'] group1_marker_size = [80, 100] group2_colors = ['purple', 'orange'] group3_colors = ['purple', 'orange'] group3_marker_size = [20, 30] # PLOT GROUP 1 and Group 2 # TO be replaced by backgorund mesh # g1_cnt = 0 # for name1,group1 in data_group1: # marker=group1_marker_type[g1_cnt] # marker_size = group1_marker_size[g1_cnt] # data_group2 = group1.groupby(group2_col) # g2_cnt=0 # for name2,group2 in data_group2: # ax.scatter(group2[x_col],group2[y_col],marker=marker,s= marker_size,color=group2_colors[g2_cnt],alpha=.4) # g2_cnt+=1 # g1_cnt+=1 # Plot with just group 1 # Plot with just group 1 and group 3 g1_cnt = 0 for name1, group1 in data_group1: marker = group1_marker_type[g1_cnt] marker_size = group3_marker_size[g1_cnt] data_group3 = group1.groupby(group3_col) g3_cnt = 0 for name3, group3 in data_group3: lbl_str = group3_col + ': ' + str(name3) if marker == 'o': ax.scatter(group3[x_col], group3[y_col], marker=marker, s=marker_size, color=group3_colors[g3_cnt], alpha=.6, label=lbl_str) g3_cnt += 1 g1_cnt += 1 # g1_cnt=0 # for name1,group1 in data_group1: # marker=group1_marker_type[g1_cnt] # marker_size=group1_marker_size[g1_cnt] # ax.scatter(group1[x_col], group1[y_col], marker=marker, s= marker_size,facecolors='cyan',edgecolors='k',alpha=.1,label=group1_col+'_'+str(name1)) # g1_cnt+=1 # break ### show_only_col show_only_data = data[data[show_only_col] == show_only_col_flag] ax.scatter(show_only_data[x_col], show_only_data[y_col], marker='*', color='red', label='Please Label Manually (' + show_only_col + ')') # # ax.legend() # plt.show() handles, labels = ax.get_legend_handles_labels() # return lines and labels interactive_legend = plugins.InteractiveLegendPlugin( zip(handles, ax.collections), labels) # alpha_unsel=0.5, # alpha_over=1.5, # start_visible=True) plugins.connect(fig, interactive_legend) ax.set_xlabel(x_col) ax.set_ylabel(y_col) ax.set_title('LOW DIM VISUALIZATION', size=20) mpld3.show()
import mpld3 from mpld3 import plugins from mpld3.utils import get_id import numpy as np import collections import matplotlib.pyplot as plt N_paths = 1 N_steps = 100 x = np.linspace(0, 10, 100) y = 0.1 * (np.random.random((N_paths, N_steps)) - 0.5) y = y.cumsum(1) fig = plt.figure() ax1 = fig.add_subplot(2, 1, 1) ax2 = fig.add_subplot(2, 1, 2) labels = ["a"] l1 = ax1.plot(x, y.T, lw=4, alpha=0.1) s1 = [] for i in range(N_paths): s = ax2.scatter(x, y[i, :], c="blue", alpha=0.1) s1.append(s) plugins.connect(fig, plugins.InteractiveLegendPlugin(l1, labels, ax=ax1)) plugins.connect(fig, plugins.InteractiveLegendPlugin(s1, labels, ax=ax2)) mpld3.show() pass
def generate_plot(tran, ambig, min_read, max_read, master_filepath_dict, lite, offset_dict, ribocoverage, organism, normalize, short_code, background_col, hili_start, hili_stop, comp_uag_col, comp_uga_col, comp_uaa_col, trips_annotation_location, title_size, subheading_size, axis_label_size, marker_size, cds_marker_size, cds_marker_colour, legend_size, transcriptome): labels = [] start_visible = [] line_collections = [] all_stops = ["TAG", "TAA", "TGA"] returnstr = "Position," y_max = 50 if normalize == True: y_max = 0 connection = sqlite3.connect('{}/trips.sqlite'.format(config.SCRIPT_LOC)) # connection = sqlite3.connect('/home/DATA/www/tripsviz/tripsviz/trips.sqlite') connection.text_factory = str cursor = connection.cursor() cursor.execute( "SELECT owner FROM organisms WHERE organism_name = '{}' and transcriptome_list = '{}';" .format(organism, transcriptome)) owner = (cursor.fetchone())[0] if owner == 1: if os.path.isfile("{0}{1}/{1}.{2}.sqlite".format( config.ANNOTATION_DIR, organism, transcriptome)): transhelve = sqlite3.connect("{0}{1}/{1}.{2}.sqlite".format( config.ANNOTATION_DIR, organism, transcriptome)) else: return "Cannot find annotation file {}.{}.sqlite".format( organism, transcriptome) else: transhelve = sqlite3.connect( "{0}transcriptomes/{1}/{2}/{3}/{2}_{3}.v2.sqlite".format( config.UPLOADS_DIR, owner, organism, transcriptome)) cursor = transhelve.cursor() cursor.execute( "SELECT * from transcripts WHERE transcript = '{}'".format(tran)) result = cursor.fetchone() traninfo = { "transcript": result[0], "gene": result[1], "length": result[2], "cds_start": result[3], "cds_stop": result[4], "seq": result[5], "strand": result[6], "stop_list": result[7].split(","), "start_list": result[8].split(","), "exon_junctions": result[9].split(","), "tran_type": result[10], "principal": result[11] } traninfo["stop_list"] = [int(x) for x in traninfo["stop_list"]] traninfo["start_list"] = [int(x) for x in traninfo["start_list"]] if str(traninfo["exon_junctions"][0]) != "": traninfo["exon_junctions"] = [ int(x) for x in traninfo["exon_junctions"] ] else: traninfo["exon_junctions"] = [] transhelve.close() gene = traninfo["gene"] tranlen = traninfo["length"] cds_start = traninfo["cds_start"] cds_stop = traninfo["cds_stop"] strand = traninfo["strand"] if cds_start == 'NULL' or cds_start == None: cds_start = 0 if cds_stop == 'NULL' or cds_stop == None: cds_stop = 0 all_starts = traninfo["start_list"] all_stops = {"TAG": [], "TAA": [], "TGA": []} seq = traninfo["seq"].upper() for i in range(0, len(seq)): if seq[i:i + 3] in all_stops: all_stops[seq[i:i + 3]].append(i + 1) start_stop_dict = { 1: { "starts": [0], "stops": { "TGA": [0], "TAG": [0], "TAA": [0] } }, 2: { "starts": [0], "stops": { "TGA": [0], "TAG": [0], "TAA": [0] } }, 3: { "starts": [0], "stops": { "TGA": [0], "TAG": [0], "TAA": [0] } } } for start in all_starts: rem = ((start - 1) % 3) + 1 start_stop_dict[rem]["starts"].append(start - 1) for stop in all_stops: for stop_pos in all_stops[stop]: rem = ((stop_pos - 1) % 3) + 1 start_stop_dict[rem]["stops"][stop].append(stop_pos - 1) fig = plt.figure(figsize=(23, 12)) ax_main = plt.subplot2grid((30, 1), (0, 0), rowspan=22) if normalize != True: label = 'Read count' else: label = 'Normalized read count' ax_main.set_ylabel(label, fontsize=axis_label_size, labelpad=30) label = 'Position (nucleotides)' ax_main.set_xlabel(label, fontsize=axis_label_size, labelpad=10) #if normalize is true work out the factors for each colour if normalize == True: all_mapped_reads = [] for color in master_filepath_dict: all_mapped_reads.append( master_filepath_dict[color]["mapped_reads"]) min_reads = float(min(all_mapped_reads)) for color in master_filepath_dict: factor = min_reads / float( master_filepath_dict[color]["mapped_reads"]) master_filepath_dict[color]["factor"] = factor # So items can be plotted alphabetically unsorted_list = [] for color in master_filepath_dict: input_list = [ color, master_filepath_dict[color]["file_names"], master_filepath_dict[color]["file_descs"], master_filepath_dict[color]["file_ids"], master_filepath_dict[color]["filepaths"], master_filepath_dict[color]["file_type"], master_filepath_dict[color]["minread"], master_filepath_dict[color]["maxread"] ] if "factor" in master_filepath_dict[color]: input_list.append(master_filepath_dict[color]["factor"]) unsorted_list.append(input_list) sorted_list = sorted(unsorted_list, key=lambda x: x[1][0]) returndict = {} for item in sorted_list: # needed to make get_reads accept file_paths file_paths = {"riboseq": {}} for i in range(0, len(item[3])): file_paths["riboseq"][item[3][i]] = item[4][i] file_names = item[1][0] file_descs = item[2] if item[5] == "riboseq": filename_reads, seqvar_dict = get_reads(ambig, item[6], item[7], tran, file_paths, tranlen, ribocoverage, organism, False, False, "fiveprime", "riboseq", 1) else: filename_reads, seqvar_dict = get_reads(ambig, item[6], item[7], tran, file_paths, tranlen, True, organism, False, False, "fiveprime", "riboseq", 1) if normalize == False: try: max_val = max(filename_reads.values()) * 1.1 if max_val > y_max: y_max = max_val except Exception as e: print "Error", e pass labels.append(file_names) start_visible.append(True) plot_filename = ax_main.plot(filename_reads.keys(), filename_reads.values(), alpha=1, label=labels, zorder=1, color=item[0], linewidth=3) line_collections.append(plot_filename) returndict[file_names] = {} for pos in filename_reads: returndict[file_names][pos] = filename_reads[pos] else: normalized_reads = {} print "Normalization is true, normalizing by factor", item[8] for pos in filename_reads: normalized_reads[pos] = filename_reads[pos] * item[8] try: max_val = max(normalized_reads.values()) * 1.1 if max_val > y_max: y_max = max_val except Exception as e: print "Error", e pass labels.append(file_names) start_visible.append(True) plot_filename = ax_main.plot(normalized_reads.keys(), normalized_reads.values(), alpha=1, label=labels, zorder=1, color=item[0], linewidth=3) line_collections.append(plot_filename) returndict[file_names] = {} for pos in filename_reads: returndict[file_names][pos] = normalized_reads[pos] for plot_filename in returndict: returnstr += "{},".format(plot_filename) returnstr += "\n" for i in range(0, tranlen): returnstr += "{},".format(i) for plot_filename in returndict: returnstr += "{},".format(returndict[plot_filename][i]) returnstr += "\n" ax_main.set_ylim(0, y_max) # draw cds start plt.plot((cds_start, cds_start), (0, y_max), cds_marker_colour, linestyle=':', linewidth=cds_marker_size) # draw cds end plt.plot((cds_stop, cds_stop), (0, y_max), cds_marker_colour, linestyle=':', linewidth=cds_marker_size) ax_f1 = plt.subplot2grid((30, 1), (27, 0), rowspan=1, sharex=ax_main) ax_f1.set_axis_bgcolor('lightgray') ax_f2 = plt.subplot2grid((30, 1), (28, 0), rowspan=1, sharex=ax_main) ax_f2.set_axis_bgcolor('lightgray') ax_f6 = plt.subplot2grid((30, 1), (29, 0), rowspan=1, sharex=ax_main) ax_f6.set_axis_bgcolor('lightgray') ax_f6.set_xlabel('Transcript: {} Length: {} nt'.format(tran, tranlen), fontsize=subheading_size, labelpad=10) for axis, frame in ((ax_f1, 1), (ax_f2, 2), (ax_f6, 3)): color = color_dict['frames'][frame - 1] axis.set_xlim(0, tranlen) starts = [(item, 1) for item in start_stop_dict[frame]['starts']] axis.broken_barh(starts, (0.5, 1), color='white', zorder=5, linewidth=2) stops = [(item, 1) for item in start_stop_dict[frame]['stops']] uag_stops = [(item, 1) for item in start_stop_dict[frame]['stops']['TAG']] uaa_stops = [(item, 1) for item in start_stop_dict[frame]['stops']['TAA']] uga_stops = [(item, 1) for item in start_stop_dict[frame]['stops']['TGA']] axis.broken_barh(uag_stops, (0, 1), color=comp_uag_col, zorder=2, linewidth=2) axis.broken_barh(uaa_stops, (0, 1), color=comp_uaa_col, zorder=2, linewidth=2) axis.broken_barh(uga_stops, (0, 1), color=comp_uga_col, zorder=2, linewidth=2) axis.set_ylabel('{}'.format(frame), rotation='horizontal', labelpad=10, verticalalignment='center') axis.set_ylim(0, 1) axis.tick_params(top=False, left=False, right=False, bottom=False, labeltop=False, labelleft=False, labelright=False, labelbottom=False) ax_f6.axes.get_yaxis().set_ticks([]) ax_f2.axes.get_yaxis().set_ticks([]) ax_f1.axes.get_yaxis().set_ticks([]) title_str = '{} ({})'.format(gene, short_code) plt.title(title_str, fontsize=title_size, y=36) if not (hili_start == 0 and hili_stop == 0): hili_start = int(hili_start) hili_stop = int(hili_stop) hili = ax_main.fill_between([hili_start, hili_stop], [y_max, y_max], zorder=0, alpha=0.75, color="#fffbaf") labels.append("Highligter") start_visible.append(True) line_collections.append(hili) leg_offset = (legend_size - 17) * 5 if leg_offset < 0: leg_offset = 0 leg_offset += 230 ilp = plugins.InteractiveLegendPlugin(line_collections, labels, alpha_unsel=0.05, xoffset=leg_offset, yoffset=20, start_visible=start_visible, fontsize=legend_size) plugins.connect(fig, ilp, plugins.TopToolbar(yoffset=100), plugins.DownloadProfile(returnstr=returnstr), plugins.DownloadPNG(returnstr=title_str)) ax_main.set_axis_bgcolor(background_col) # This changes the size of the tick markers, works on both firefox and chrome. ax_main.tick_params('both', labelsize=marker_size) ax_main.xaxis.set_major_locator(plt.MaxNLocator(3)) ax_main.yaxis.set_major_locator(plt.MaxNLocator(3)) ax_main.grid(color="white", linewidth=20, linestyle="solid") graph = "<div style='padding-left: 55px;padding-top: 22px;'> <a href='https://trips.ucc.ie/short/{0}' target='_blank' ><button class='button centerbutton' type='submit'><b>Direct link to this plot</b></button></a> </div>".format( short_code) graph += mpld3.fig_to_html(fig) return graph
#set tick marks as blank ax.axes.get_xaxis().set_ticks([]) ax.axes.get_yaxis().set_ticks([]) #set axis as blank ax.axes.get_xaxis().set_visible(False) ax.axes.get_yaxis().set_visible(False) #next shoul be done at the en of loop for I guess #TitFic = ['file:///D:/Doc-David/Developpement/SpyderWorkspace/Git-P2N/DATA/Banana/PatentContents/Metrics/' +Tit2FicName [lab] for lab in labels] TitFic = ['file:///' + Here + Tit2FicName[lab] for lab in labels] tempoLab.append(labels) tempoFic.append(TitFic) interactive_legend = plugins.InteractiveLegendPlugin(memoFig, memoLab, legend_offset=(0, 300), alpha_unsel=0.1, alpha_over=0.9, start_visible=False) interactive_legend2 = plugins.InteractiveLegendPlugin(memoFig2, memoLab2, legend_offset=(0, 0), alpha_unsel=0.1, alpha_over=0.8, start_visible=False) #TitFics = [] #tempoFic=[] mpld3.plugins.connect(fig, interactive_legend) mpld3.plugins.connect(fig, interactive_legend2) tooltip = dict()
def plot_norm_cart_interacive_az(az_co, az_cr, fname, save_dir): plt.ioff() #Defining a list of colors colours = list([ "blue", "green", "red", "cyan", "magenta", "yellow", "black", "tan", "firebrick", "plum", "aqua", "darkblue", "crimson", "pink", "chocolate", "darkgrey", "blue", "green", "red", "cyan", "magenta", "yellow", "black", "tan", "firebrick", "plum", "aqua", "darkblue", "crimson", "pink", "chocolate", "darkgrey" ]) #Convert data so that we can use it az_co = az_co.convert_objects(convert_numeric=True) az_cr = az_cr.convert_objects(convert_numeric=True) az_co, az_cr = Sector.normalise2("", az_co, az_cr) #X axis x1 = np.arange(0, 360, 1) #List of all frequencies key_list = list(az_co.keys()) fig, ax = plt.subplots(figsize=(12, 7)) fig.subplots_adjust(right=.8) #List of all lines ln = list() #Loop plotting both the co and cross for each frequency for i in range(len(key_list)): co = az_co[key_list[i]] cr = az_cr[key_list[i]] y1 = np.array([co.as_matrix(), cr.as_matrix()]) ln.append(ax.plot(x1, y1.T, lw=1.6, alpha=0.9, label=key_list[i])) #,c=colours[i])) #Link up interactive legend plugins.connect( fig, plugins.InteractiveLegendPlugin(ln, key_list, alpha_unsel=0.05, alpha_over=1.5, start_visible=False)) ########################################################################### # Figure Settings #Set axis parameters ax.grid(alpha=0.25) ax.set_ylim([-40, 0.5]) ax.set_xlim([0, 360]) x_tick_spacing = 20 y_tick_spacing = 3 ax.xaxis.set_major_locator(ticker.MultipleLocator(x_tick_spacing)) ax.yaxis.set_major_locator(ticker.MultipleLocator(y_tick_spacing)) #Set Plot title & axis titles ax.set_ylabel('dBi') ax.set_xlabel('Angle') ax.set_ylim([-40, 0.5]) ax.set_xlim([0, 360]) #ax.set_title(fname) ax.set_title(fname) #Save the figure as a html mpld3.save_html(fig, save_dir + fname + ".html") plt.close('all') plt.ion()
'Washington', 'West Virginia', 'Wisconsin', 'Wyoming' ] #lines,places = runcovid() for i in range(len(places)): fv = gaussian_filter1d(lines[i], sigma=3) #fvfin = lines[i][:cleanuppt] + fv x, = ax.plot(fv, label=places[i]) #x2, = ax.plot(np.arange(cleanuppt,len(lines[i])),fv[cleanuppt:],color=x.get_color(),linestyle=(0, (1, 1))) plt.ylim([0, 700000]) plt.xlim([0, len(lines[0])]) handles, labels = ax.get_legend_handles_labels() # return lines and labels interactive_legend = plugins.InteractiveLegendPlugin(handles, labels, font_size=13, start_visible=False) fig.subplots_adjust(right=0.7) #ax.axvline(x=cleanuppt,linewidth=0.4,color='r') ax.vlines( x=cleanuppt, ymin=0, ymax=700000, colors='r', linewidth=1, linestyles='dotted', label="Today", )
def generate_plot(tran, ambig, min_read, max_read, lite, ribocoverage, organism, readscore, noisered, primetype, minfiles, nucseq, user_hili_starts, user_hili_stops, uga_diff, file_paths_dict, short_code, color_readlen_dist, background_col, uga_col, uag_col, uaa_col, advanced, trips_annotation_location, seqhili, seq_rules, title_size, subheading_size, axis_label_size, marker_size, transcriptome, trips_uploads_location, cds_marker_size, cds_marker_colour, legend_size, ribo_linewidth, secondary_readscore, pcr, mismatches, hili_start, hili_stop): if lite == "n" and ribocoverage == True: return "Error: Cannot display Ribo-Seq Coverage when 'Line Graph' is turned off" labels = [ "Frame 1 profiles", "Frame 2 profiles", "Frame 3 profiles", "RNA", "Exon Junctions" ] start_visible = [True, True, True, True, False] if mismatches == True: labels.append("Mismatches A") labels.append("Mismatches T") labels.append("Mismatches G") labels.append("Mismatches C") start_visible.append(False) start_visible.append(False) start_visible.append(False) start_visible.append(False) start_visible.append(True) labels.append("CDS markers") #This is a list of booleans that decide if the interactive legends boxes are filled in or not.Needs to be same length as labels stop_codons = ["TAG", "TAA", "TGA"] frame_orfs = {1: [], 2: [], 3: []} connection = sqlite3.connect( '/home/DATA/www/tripsviz/tripsviz/trips.sqlite') connection.text_factory = str cursor = connection.cursor() cursor.execute( "SELECT owner FROM organisms WHERE organism_name = '{}' and transcriptome_list = '{}';" .format(organism, transcriptome)) owner = (cursor.fetchone())[0] if owner == 1: transhelve = sqlite3.connect("{0}{1}/{1}.v2.sqlite".format( trips_annotation_location, organism)) else: transhelve = sqlite3.connect( "{0}transcriptomes/{1}/{2}/{3}/{2}_{3}.v2.sqlite".format( trips_uploads_location, owner, organism, transcriptome)) cursor = transhelve.cursor() cursor.execute( "SELECT * from transcripts WHERE transcript = '{}'".format(tran)) result = cursor.fetchone() traninfo = { "transcript": result[0], "gene": result[1], "length": result[2], "cds_start": result[3], "cds_stop": result[4], "seq": result[5], "strand": result[6], "stop_list": result[7].split(","), "start_list": result[8].split(","), "exon_junctions": result[9].split(","), "tran_type": result[10], "principal": result[11] } try: traninfo["stop_list"] = [int(x) for x in traninfo["stop_list"]] except: traninfo["stop_list"] = [] try: traninfo["start_list"] = [int(x) for x in traninfo["start_list"]] except: traninfo["start_list"] = [] if str(traninfo["exon_junctions"][0]) != "": traninfo["exon_junctions"] = [ int(x) for x in traninfo["exon_junctions"] ] else: traninfo["exon_junctions"] = [] transhelve.close() gene = traninfo["gene"] tranlen = traninfo["length"] cds_start = traninfo["cds_start"] cds_stop = traninfo["cds_stop"] if cds_start == "NULL" or cds_start == None: cds_start = 0 if cds_stop == "NULL" or cds_stop == None: cds_stop = 0 all_starts = traninfo["start_list"] all_stops = {"TAG": [], "TAA": [], "TGA": []} exon_junctions = traninfo["exon_junctions"] seq = traninfo["seq"].upper() for i in range(0, len(seq)): if seq[i:i + 3] in stop_codons: all_stops[seq[i:i + 3]].append(i + 1) # Error occurs if one of the frames is empty for any given start/stop, so we initialise with -5 as this won't be seen by user and will prevent the error start_stop_dict = { 1: { "starts": [-5], "stops": { "TGA": [-5], "TAG": [-5], "TAA": [-5] } }, 2: { "starts": [-5], "stops": { "TGA": [-5], "TAG": [-5], "TAA": [-5] } }, 3: { "starts": [-5], "stops": { "TGA": [-5], "TAG": [-5], "TAA": [-5] } } } for start in all_starts: rem = ((start - 1) % 3) + 1 start_stop_dict[rem]["starts"].append(start) for stop in all_stops: for stop_pos in all_stops[stop]: rem = ((stop_pos - 1) % 3) + 1 start_stop_dict[rem]["stops"][stop].append(stop_pos) #find all open reading frames for frame in [1, 2, 3]: for start in start_stop_dict[frame]["starts"]: best_stop_pos = 10000000 for stop in start_stop_dict[frame]["stops"]: for stop_pos in start_stop_dict[frame]["stops"][stop]: if stop_pos > start and stop_pos < best_stop_pos: best_stop_pos = stop_pos if best_stop_pos != 10000000: frame_orfs[frame].append((start, best_stop_pos)) all_rna_reads, rna_seqvar_dict = get_reads(ambig, min_read, max_read, tran, file_paths_dict, tranlen, True, organism, False, noisered, primetype, "rnaseq", readscore, pcr, get_mismatches=mismatches) all_subcodon_reads, ribo_seqvar_dict = get_reads(ambig, min_read, max_read, tran, file_paths_dict, tranlen, ribocoverage, organism, True, noisered, primetype, "riboseq", readscore, secondary_readscore, pcr, get_mismatches=mismatches) seq_var_dict = merge_dicts(ribo_seqvar_dict, rna_seqvar_dict) try: rnamax = max(all_rna_reads.values()) except: rnamax = 0 try: subcodonmax = max(all_subcodon_reads.values()) except: subcodonmax = 0 y_max = max(1, rnamax, subcodonmax) * 1.1 fig = plt.figure(figsize=(23, 12)) ax_main = plt.subplot2grid((30, 1), (0, 0), rowspan=22) ax_main.spines['bottom'].set_visible(False) alt_seq_type_vars = [] # Plot any alternative sequence types if there are any for seq_type in file_paths_dict: if seq_type != "riboseq" and seq_type != "rnaseq": if seq_rules[seq_type]["frame_breakdown"] == 1: frame_breakdown = True else: frame_breakdown = False alt_sequence_reads, empty_seqvar_dict = get_reads( ambig, min_read, max_read, tran, file_paths_dict, tranlen, True, organism, frame_breakdown, noisered, primetype, seq_type, readscore) if frame_breakdown == False: alt_seq_plot = ax_main.plot(alt_sequence_reads.keys(), alt_sequence_reads.values(), alpha=1, label=seq_type, zorder=2, color='lightblue', linewidth=2) labels.append(seq_type) start_visible.append(True) alt_seq_type_vars.append(alt_seq_plot) else: alt_frame_counts = { 0: collections.OrderedDict(), 1: collections.OrderedDict(), 2: collections.OrderedDict() } for key in alt_sequence_reads: start = key rem = start % 3 if rem == 1: # frame 1 frame = 2 elif rem == 2: # frame 2 frame = 0 elif rem == 0: # frame 3 frame = 1 alt_frame_counts[frame][key] = alt_sequence_reads[key] frame0_altseqplot = ax_main.plot(alt_frame_counts[0].keys(), alt_frame_counts[0].values(), alpha=0.75, label=seq_type + "frame0", zorder=2, color="#FF4A45", linewidth=2) frame1_altseqplot = ax_main.plot(alt_frame_counts[1].keys(), alt_frame_counts[1].values(), alpha=0.75, label=seq_type + "frame1", zorder=2, color="#64FC44", linewidth=2) frame2_altseqplot = ax_main.plot(alt_frame_counts[2].keys(), alt_frame_counts[2].values(), alpha=0.75, label=seq_type + "frame2*", zorder=2, color="#5687F9", linewidth=2) labels.append(seq_type + "frame 1") labels.append(seq_type + "frame 2") labels.append(seq_type + "frame 3") start_visible.append(True) start_visible.append(True) start_visible.append(True) alt_seq_type_vars.append(frame0_altseqplot) alt_seq_type_vars.append(frame1_altseqplot) alt_seq_type_vars.append(frame2_altseqplot) if max(alt_sequence_reads.values()) > y_max: y_max = max(alt_sequence_reads.values()) label = 'Read count' ax_main.set_ylabel(label, fontsize=axis_label_size, labelpad=30) label = 'Position (nucleotides)' ax_main.set_xlabel(label, fontsize=axis_label_size) ax_main.set_ylim(0, y_max) if lite == "n": rna_bars = ax_main.bar(all_rna_reads.keys(), all_rna_reads.values(), alpha=1, label=labels, zorder=1, color='lightgray', linewidth=0, width=1) else: rna_bars = ax_main.plot(all_rna_reads.keys(), all_rna_reads.values(), alpha=1, label=labels, zorder=1, color='#a7adb7', linewidth=4) #if lite == "n": # all_profiles = ax_main.bar(all_ribo_reads.keys(), all_ribo_reads.values(), alpha=0.01, label = labels, zorder=2, color='crimson', linewidth=0,width=1) #else: # all_profiles = ax_main.plot(all_ribo_reads.keys(), all_ribo_reads.values(), alpha=0.01, label = labels, zorder=2, color='crimson', linewidth=1) cds_markers = ax_main.plot((cds_start + 1, cds_start + 1), (0, y_max), color=cds_marker_colour, linestyle='solid', linewidth=cds_marker_size) cds_markers += ax_main.plot((cds_stop + 1, cds_stop + 1), (0, y_max), color=cds_marker_colour, linestyle='solid', linewidth=cds_marker_size) ax_f1 = plt.subplot2grid((30, 1), (26, 0), rowspan=1, sharex=ax_main) ax_f1.set_axis_bgcolor(color_dict['frames'][0]) ax_f2 = plt.subplot2grid((30, 1), (27, 0), rowspan=1, sharex=ax_main) ax_f2.set_axis_bgcolor(color_dict['frames'][1]) ax_f3 = plt.subplot2grid((30, 1), (28, 0), rowspan=1, sharex=ax_main) ax_f3.set_axis_bgcolor(color_dict['frames'][2]) ax_nucseq = plt.subplot2grid((30, 1), (29, 0), rowspan=1, sharex=ax_main) ax_nucseq.set_xlabel('Transcript: {} Length: {} nt'.format(tran, tranlen), fontsize=subheading_size, labelpad=10) #plot a dummy exon junction at postion -1, needed in cases there are no exon junctions, this wont be seen allexons = ax_main.plot((-1, -1), (0, 1), alpha=0.01, color='black', linestyle='-.', linewidth=2) for exon in exon_junctions: allexons += ax_main.plot((exon, exon), (0, y_max), alpha=0.01, color='black', linestyle='-.', linewidth=3) #dictionary for each frame in which the keys are the posistions and the values are the counts frame_counts = { 0: collections.OrderedDict(), 1: collections.OrderedDict(), 2: collections.OrderedDict() } for key in all_subcodon_reads: rem = key % 3 if rem == 1: # frame 1 frame = 2 elif rem == 2: # frame 2 frame = 0 elif rem == 0: # frame 3 frame = 1 frame_counts[frame][key] = all_subcodon_reads[key] if lite == "n": frame_counts[frame][key + 1] = 0 frame_counts[frame][key + 2] = 0 if lite == "n": frame0subpro = ax_main.bar(frame_counts[0].keys(), frame_counts[0].values(), alpha=0.75, label=labels, zorder=2, color="#FF4A45", width=1, linewidth=0) frame1subpro = ax_main.bar(frame_counts[1].keys(), frame_counts[1].values(), alpha=0.75, label=labels, zorder=2, color="#64FC44", width=1, linewidth=0) frame2subpro = ax_main.bar(frame_counts[2].keys(), frame_counts[2].values(), alpha=0.75, label=labels, zorder=2, color="#5687F9", width=1, linewidth=0) else: frame0subpro = ax_main.plot(frame_counts[0].keys(), frame_counts[0].values(), alpha=0.75, label=labels, zorder=2, color="#FF4A45", linewidth=ribo_linewidth) frame1subpro = ax_main.plot(frame_counts[1].keys(), frame_counts[1].values(), alpha=0.75, label=labels, zorder=2, color="#64FC44", linewidth=ribo_linewidth) frame2subpro = ax_main.plot(frame_counts[2].keys(), frame_counts[2].values(), alpha=0.75, label=labels, zorder=2, color="#5687F9", linewidth=ribo_linewidth) if mismatches == True: a_mismatches = ax_main.plot(seq_var_dict["A"].keys(), seq_var_dict["A"].values(), alpha=0.01, label=labels, zorder=2, color="purple", linewidth=2) t_mismatches = ax_main.plot(seq_var_dict["T"].keys(), seq_var_dict["T"].values(), alpha=0.01, label=labels, zorder=2, color="yellow", linewidth=2) g_mismatches = ax_main.plot(seq_var_dict["G"].keys(), seq_var_dict["G"].values(), alpha=0.01, label=labels, zorder=2, color="orange", linewidth=2) c_mismatches = ax_main.plot(seq_var_dict["C"].keys(), seq_var_dict["C"].values(), alpha=0.01, label=labels, zorder=2, color="pink", linewidth=2) xy = 0 if nucseq == True: ax_nucseq.set_axis_bgcolor(background_col) mrnaseq = seq.replace("T", "U") for char in mrnaseq: ax_nucseq.text((xy + 1) - 0.1, 0.2, mrnaseq[xy], fontsize=20, color="grey") xy += 1 # If the user passed a list of sequences to highlight, find and plot them here. if seqhili != ['']: near_cog_starts, signalhtml = get_user_defined_seqs(seq, seqhili) for slip in near_cog_starts[0]: try: hili_sequences += ax_f1.plot((slip, slip), (0, 0.5), alpha=1, label=labels, zorder=4, color='black', linewidth=5) except Exception as e: hili_sequences = ax_f1.plot((slip, slip), (0, 0.5), alpha=1, label=labels, zorder=4, color='black', linewidth=5) for slip in near_cog_starts[1]: try: hili_sequences += ax_f2.plot((slip, slip), (0, 0.5), alpha=1, label=labels, zorder=4, color='black', linewidth=5) except: hili_sequences = ax_f2.plot((slip, slip), (0, 0.5), alpha=1, label=labels, zorder=4, color='black', linewidth=5) for slip in near_cog_starts[2]: try: hili_sequences += ax_f3.plot((slip, slip), (0, 0.5), alpha=1, label=labels, zorder=4, color='black', linewidth=5) except: hili_sequences = ax_f3.plot((slip, slip), (0, 0.5), alpha=1, label=labels, zorder=4, color='black', linewidth=5) #Plot sequence identifiers which will create a popup telling user what the subsequence is (useful if they have passed multiple subsequences) frame1_subsequences = ax_f1.plot(near_cog_starts[0], [0.25] * len(near_cog_starts[0]), 'o', color='b', mec='k', ms=12, mew=1, alpha=0, zorder=4) frame2_subsequences = ax_f2.plot(near_cog_starts[1], [0.25] * len(near_cog_starts[1]), 'o', color='b', mec='k', ms=12, mew=1, alpha=0, zorder=4) frame3_subsequences = ax_f3.plot(near_cog_starts[2], [0.25] * len(near_cog_starts[2]), 'o', color='b', mec='k', ms=12, mew=1, alpha=0, zorder=4) #Attach the labels to the subsequences plotted above signaltooltip1 = plugins.PointHTMLTooltip(frame1_subsequences[0], signalhtml[0], voffset=10, hoffset=10, css=point_tooltip_css) signaltooltip2 = plugins.PointHTMLTooltip(frame2_subsequences[0], signalhtml[1], voffset=10, hoffset=10, css=point_tooltip_css) signaltooltip3 = plugins.PointHTMLTooltip(frame3_subsequences[0], signalhtml[2], voffset=10, hoffset=10, css=point_tooltip_css) for axisname in (ax_f1, ax_f2, ax_f3, ax_nucseq): axisname.tick_params(top=False, bottom=False, labelleft=False, labelright=False, labelbottom=False) for label in ax_main.xaxis.get_majorticklabels(): label.set_fontsize(36) for axis, frame in ((ax_f1, 1), (ax_f2, 2), (ax_f3, 3)): axis.set_xlim(1, tranlen) starts = [(item, 1) for item in start_stop_dict[frame]['starts']] uag_stops = [(item, 1) for item in start_stop_dict[frame]['stops']['TAG']] uaa_stops = [(item, 1) for item in start_stop_dict[frame]['stops']['TAA']] uga_stops = [(item, 1) for item in start_stop_dict[frame]['stops']['TGA']] axis.broken_barh(starts, (0.5, 1), color="white", zorder=2) axis.broken_barh(uag_stops, (0, 1), color=uag_col, zorder=2, linewidth=2) axis.broken_barh(uaa_stops, (0, 1), color=uaa_col, zorder=2, linewidth=2) axis.broken_barh(uga_stops, (0, 1), color=uga_col, zorder=2, linewidth=2) axis.set_ylim(0, 1) axis.set_ylabel('{}'.format(frame), labelpad=10, verticalalignment='center', rotation="horizontal", color="black") title_str = '{} ({})'.format(gene, short_code) plt.title(title_str, fontsize=title_size, y=36) line_collections = [ frame0subpro, frame1subpro, frame2subpro, rna_bars, allexons ] if mismatches == True: line_collections.append(a_mismatches) line_collections.append(t_mismatches) line_collections.append(g_mismatches) line_collections.append(c_mismatches) line_collections.append(cds_markers) if not (hili_start == 0 and hili_stop == 0): hili_start = int(hili_start) hili_stop = int(hili_stop) hili = ax_main.fill_between([hili_start, hili_stop], [y_max, y_max], zorder=0, alpha=0.75, color="#fffbaf") labels.append("Highligted region") start_visible.append(True) line_collections.append(hili) for alt_plot in alt_seq_type_vars: line_collections.append(alt_plot) if 'hili_sequences' in locals(): labels.append("Highligted sequences") start_visible.append(True) line_collections.append(hili_sequences) if user_hili_starts != [] and user_hili_stops != []: for i in range(0, len(user_hili_starts)): user_hili_start = int(user_hili_starts[i]) user_hili_stop = int(user_hili_stops[i]) try: hili += ax_main.fill_between([user_hili_start, user_hili_stop], [y_max, y_max], alpha=0.75, color="#fffbaf") except: hili = ax_main.fill_between([user_hili_start, user_hili_stop], [y_max, y_max], alpha=0.75, color="#fffbaf") labels.append("Highligter") start_visible.append(True) line_collections.append(hili) leg_offset = (legend_size - 17) * 5 if leg_offset < 0: leg_offset = 0 ilp = plugins.InteractiveLegendPlugin(line_collections, labels, alpha_unsel=0, alpha_sel=0.85, start_visible=start_visible, fontsize=legend_size, xoffset=leg_offset) htmllabels = {1: [], 2: [], 3: []} all_start_points = {1: [], 2: [], 3: []} try: con_scores = SqliteDict("{0}homo_sapiens/score_dict.sqlite".format( trips_annotation_location)) except Exception as e: print "Couldn't open conservation scores " + e con_scores = [] for frame in [1, 2, 3]: orf_list = frame_orfs[frame] for tup in orf_list: orf_ribo = 0.0 outframe_ribo = 0.0 orf_rna = 0.0001 start = tup[0] try: context = (seq[start - 7:start + 4].upper()).replace("T", "U") except Exception as e: con_score = "?" if len(context) != 11 or context[6:9] != "AUG": con_score = "?" else: try: con_score = con_scores[context.upper()] except Exception as e: con_score = "?" all_start_points[frame].append(start - 1) stop = tup[1] other_ribo = 0.0 otherother_ribo = 0.0 for i in range(start + 2, stop, 3): for subframe in [0, 1, 2]: if i in frame_counts[subframe]: orf_ribo += frame_counts[subframe][i] for i in range(start, stop, 3): for subframe in [0, 1, 2]: if i in frame_counts[subframe]: outframe_ribo += frame_counts[subframe][i] for i in range(start + 1, stop, 3): for subframe in [0, 1, 2]: if i in frame_counts[subframe]: outframe_ribo += frame_counts[subframe][i] for i in range(start, stop + 1): if i in all_rna_reads: orf_rna += all_rna_reads[i] orf_te = float(orf_ribo) / float(orf_rna) orf_len = int(stop - start) try: in_out_ratio = orf_ribo / outframe_ribo except: in_out_ratio = "Null" datadict = { 'inframe ribo': [orf_ribo], 'outframe ribo': [outframe_ribo], 'in/out ratio': [in_out_ratio], 'rna': [orf_rna], 'te': [orf_te], 'len': [orf_len], 'context_score': [str(con_score) + "/150"] } df = pd.DataFrame(datadict, columns=([ "inframe ribo", "outframe ribo", "in/out ratio", "rna", "te", "len", "context_score" ])) label = df.ix[[0], :].T label.columns = ["Start pos: {}".format(start - 1)] htmllabels[frame].append(str(label.to_html())) points1 = ax_f1.plot(all_start_points[1], [0.75] * len(all_start_points[1]), 'o', color='b', mec='k', ms=13, mew=1, alpha=0, zorder=3) points2 = ax_f2.plot(all_start_points[2], [0.75] * len(all_start_points[2]), 'o', color='b', mec='k', ms=13, mew=1, alpha=0, zorder=3) points3 = ax_f3.plot(all_start_points[3], [0.75] * len(all_start_points[3]), 'o', color='b', mec='k', ms=13, mew=1, alpha=0, zorder=3) tooltip1 = plugins.PointHTMLTooltip(points1[0], htmllabels[1], voffset=10, hoffset=10, css=point_tooltip_css) tooltip2 = plugins.PointHTMLTooltip(points2[0], htmllabels[2], voffset=10, hoffset=10, css=point_tooltip_css) tooltip3 = plugins.PointHTMLTooltip(points3[0], htmllabels[3], voffset=10, hoffset=10, css=point_tooltip_css) ax_f3.axes.get_yaxis().set_ticks([]) ax_f2.axes.get_yaxis().set_ticks([]) ax_f1.axes.get_yaxis().set_ticks([]) returnstr = "Position,Sequence,Frame 1,Frame 2, Frame 3,RNA-Seq\n" for i in range(0, len(seq)): f1_count = 0 f2_count = 0 f3_count = 0 rna_count = 0 if i + 1 in frame_counts[0]: f1_count = frame_counts[0][i + 1] elif i + 1 in frame_counts[1]: f2_count = frame_counts[1][i + 1] elif i + 1 in frame_counts[2]: f3_count = frame_counts[2][i + 1] if i + 1 in all_rna_reads: rna_count = all_rna_reads[i + 1] returnstr += "{},{},{},{},{},{}\n".format(i + 1, seq[i], f1_count, f2_count, f3_count, rna_count) if seqhili == ['']: plugins.connect(fig, ilp, tooltip1, tooltip2, tooltip3, plugins.TopToolbar(yoffset=100), plugins.DownloadProfile(returnstr=returnstr), plugins.DownloadPNG(returnstr=title_str)) else: plugins.connect(fig, ilp, tooltip1, tooltip2, tooltip3, signaltooltip1, signaltooltip2, signaltooltip3, plugins.TopToolbar(yoffset=100), plugins.DownloadProfile(returnstr=returnstr), plugins.DownloadPNG(returnstr=title_str)) ax_main.set_axis_bgcolor(background_col) # This changes the size of the tick markers, works on both firefox and chrome. ax_main.tick_params('both', labelsize=marker_size) ax_main.xaxis.set_major_locator(plt.MaxNLocator(3)) ax_main.yaxis.set_major_locator(plt.MaxNLocator(3)) ax_main.grid(True, color="white", linewidth=30, linestyle="solid") #Without this style tag the markers sizes will appear correct on browser but be original size when downloaded via png graph = "<style>.mpld3-xaxis {{font-size: {0}px;}} .mpld3-yaxis {{font-size: {0}px;}}</style>".format( marker_size) graph += "<div style='padding-left: 55px;padding-top: 22px;'> <a href='https://trips.ucc.ie/short/{0}' target='_blank' ><button class='button centerbutton' type='submit'><b>Direct link to this plot</b></button></a> </div>".format( short_code) graph += mpld3.fig_to_html(fig) return graph
def nearest(self, points1=None, points2=None, file1=None, file2=None): try: if file1 is None: raise Exception("File now found") if points1 is not None and points2 is None: fig, ax = plt.subplots(figsize=(15, 10)) p = ax.scatter(points1['x'], points1['y'], s=15, color='b', marker='o', alpha=.3) labels = [] for i in range(points1.shape[0]): label = points1.ix[[i], :].T label.columns = ['Row {0}'.format(0)] labels.append(str(label.to_html())) # Setting axis label ax.set_xlabel('X') ax.set_ylabel('Y') ax.set_title('{} Nearest Neighbor'.format(file1), size=60) # for i, point in points1.iterrows(): # x = float(point.x + 0.050) # y = float(point.y + 0.050) # w = str(point.word) # # ax.text(x, y, w, fontsize=11) # Plugins for tooltip tooltip = plugins.PointHTMLTooltip(p, labels, voffset=10, hoffset=10, css=css) plugins.connect(fig, tooltip) mpld3.show() if points1 is not None and points2 is not None: fig, ax = plt.subplots(figsize=(15, 10)) p1 = ax.scatter(points1['x'], points1['y'], s=15, color='b', marker='o', alpha=.3, label=file1) p2 = ax.scatter(points2['x'], points2['y'], s=15, color='r', marker='o', alpha=.3, label=file2) labels = [] for i in range(points1.shape[0]): label = points1.ix[[i], :].T label.columns = ['Row {0}'.format(0)] labels.append(str(label.to_html())) labels2 = [] for i in range(points2.shape[0]): label = points2.ix[[i], :].T label.columns = ['Row {0}'.format(0)] labels2.append(str(label.to_html())) ax.set_xlabel('X') ax.set_ylabel('Y') ax.set_title('{} vs {} - Nearest Neighbor'.format( file1, file2), size=15) legend_labels = [file1, file2] plot_collection = [p1, p2] legend = plugins.InteractiveLegendPlugin( plot_collection, legend_labels) tooltip = plugins.PointHTMLTooltip(p1, labels, voffset=10, hoffset=10, css=css) tooltip2 = plugins.PointHTMLTooltip(p2, labels2, voffset=10, hoffset=10, css=css) plugins.connect(fig, legend) plugins.connect(fig, tooltip) plugins.connect(fig, tooltip2) mpld3.show() except Exception as e: logger.getLogger().error(e) return # print(doc2vec.most_similar("security")) pass
# x = np.linspace(0, 10, 100) # y = 0.1 * (np.random.random((N_paths, N_steps)) - 0.5) # y = y.cumsum(1) # # # fig = plt.figure() # ax1 = fig.add_subplot(2,1,1) # ax2 = fig.add_subplot(2,1,2) # # labels = ["a", "b", "c", "d", "e"] # l1 = ax1.plot(x, y.T, marker='x',lw=2, alpha=0.1) # s1 = ax2.plot(x, y.T, 'o', ms=8, alpha=0.1) ipdb.set_trace() ilp = plugins.InteractiveLegendPlugin(zip(l1, s1), labels) ilp.JAVASCRIPT = """ mpld3.register_plugin("interactive_legend", InteractiveLegend); InteractiveLegend.prototype = Object.create(mpld3.Plugin.prototype); InteractiveLegend.prototype.constructor = InteractiveLegend; InteractiveLegend.prototype.requiredProps = ["element_ids", "labels"]; InteractiveLegend.prototype.defaultProps = {"ax":null, "alpha_unsel":0.2, "alpha_over":1.0, "start_visible":true} function InteractiveLegend(fig, props){ mpld3.Plugin.call(this, fig, props); }; InteractiveLegend.prototype.draw = function(){ var alpha_unsel = this.props.alpha_unsel;
tmp_dict = {} for vals in v: if vals not in tmp_dict: tmp_dict[vals] = 0.0 else: tmp_dict[vals] += 1.0 if sys.argv[2] == 'p': #for percentage graph for j, v in tmp_dict.iteritems(): tmp_dict[j] /= count_dict[j] x, y = zip(*sorted(tmp_dict.items())) line_collections.append(ax.plot_date(x, y, '-')) #order titles to correspond with graph ordered_titles.append(label_titles[int(k)]) #make interactive legend interactive_legend = plugins.InteractiveLegendPlugin(line_collections, ordered_titles) #set up graph ax.set_ylabel("Number of Tweets Per Day") ax.set_xlabel("Time") if sys.argv[2] == 'p': name += "_percentage" elif sys.argv[2] == 'n': name += "_counts" ax.set_title("Topics Distribution During Hurricane Irma (Random Forest) (" + name + ")") #connect matplotlib to d3 so it can be hosted in browser mpld3.plugins.connect(fig, interactive_legend) fig.set_size_inches(26.5, 12.5) html_string = mpld3.fig_to_html(fig) #mpld3.show() #uncomment this to show graph locally
def _create_interactive_network_graph(json_data): """ Creates a network graph with draggable nodes Interface colors represent utilization. Tooltips show node name and interface info. This graph cannot show multiple parallel circuits between the same nodes. lightgray = circuit/node is down Interface utilization coloring (colors from named_colors.py): 0-25% = blue 25-50% = green 50-75% = yellow 75-90% = orangered 90-100% = red > 100% = darkviolet """ # Prepare the plot fig, ax = plt.subplots(figsize=(15, 15)) ax.set_facecolor('tan') # Plot the lines on ax links_iterator = (link for link in json_data['links']) for link in links_iterator: # Edge x,y coordinates x_coordinates = [] y_coordinates = [] # # Get the utilization # util = None # if 'failed' in link['utilization']: # util_split = link['utilization'].split('%') # util = util_split[0].split()[-1] # else: # util = link['utilization'].split('%')[0] # Node plot stuff node_tool_tip_labels = [] # Get the source node src = link['source'] # Get the target node target = link['target'] # Get source node position and label for node in json_data['nodes']: if node['name'] == src: source_y, source_x = node['pos'] node_tool_tip_labels.append(node['name']) break # Get target node position and label for node in json_data['nodes']: if node['name'] == target: target_y, target_x = node['pos'] if node['failed'] is False: node_tool_tip_labels.append(node['name']) else: node_tool_tip_labels.append((node['name'] + ' (failed)')) break # Get the coordinates of the nodes for the line src_x = None src_y = None dest_x = None dest_y = None node_iterator = (node for node in json_data['nodes']) for node in node_iterator: if node['name'] == link['source']: src_y, src_x = node['pos'] if node['name'] == link['target']: dest_y, dest_x = node['pos'] if None not in (src_x, src_y, dest_x, dest_y != [None, None, None, None]): break x_coordinates = [src_x, dest_x] y_coordinates = [src_y, dest_y] # Plot only the relevant nodes to the line nodes_on_plot = ax.plot(x_coordinates, y_coordinates, 'o', color='r', alpha=0.7, markersize=15, markeredgewidth=1) # Plot the line line = ax.plot(x_coordinates, y_coordinates, color=link['color'], linewidth=5.0, label=link['color']) # Need to normalize some stuff for the line labels for the line tooltips link_source = _find_link_source_node(link) line_labels = [ 'from-' + link['target'] + '-to-' + link_source + '; \ utilization = ' + link['utilization'] ] # Add the tooltip labels to lines. # Notice we use the *LineLabelTooltip mpld3.plugins.connect( fig, mpld3.plugins.LineLabelTooltip(line[0], label=line_labels)) # Drag plugin for nodes mpld3.plugins.connect(fig, LinkedDragPlugin(nodes_on_plot[0], line[0])) # Add the tooltip node labels # Notice we use the *PointLabelTooltip mpld3.plugins.connect( fig, mpld3.plugins.PointLabelTooltip(nodes_on_plot[0], labels=node_tool_tip_labels)) # Plot the midpoint node labels for node in (node for node in json_data['nodes'] if 'midpoint' in node['id']): x, y = node['pos'][1], node['pos'][0] text = node['name'] ax.text(x, y, text, fontsize=10, color='k', fontname='monospace') # Plot the router node labels for node in (node for node in json_data['nodes'] if 'midpoint' not in node['id']): x, y = node['pos'][1], node['pos'][0] if node['failed'] is False: text = node['name'] else: text = node['name'] + ' (failed)' ax.text(x, y, text, fontsize=15, color='k', fontname='monospace') # Create interactive legend line_collections, line_group_labels = _create_legend_line_collections(ax) interactive_legend = plugins.InteractiveLegendPlugin(line_collections, line_group_labels, alpha_unsel=0.2, alpha_over=1.8, start_visible=True) fig.subplots_adjust(right=0.85) plugins.connect(fig, interactive_legend) time_now = str(time.asctime()) ax.set_title("Network Graph:" + time_now, size=15) plot_thread = threading.Thread(target=_run_plot) plot_thread.start()
# import matplotlib.pyplot as plt, mpld3 # from mpld3 import plugins # fig, ax = plt.subplots(1,1) # xx = yy = range(10) # scat = ax.scatter(xx, range(10)) # targets = map(lambda (x, y): "<marquee>It works!<br><h1>{}, {}</h1></marquee>".format(x, y), # zip(xx, yy)) # labels = map(lambda (x, y): "{}, {}".format(x,y), zip(xx, yy)) # from mpld3.plugins import PointClickableHTMLTooltip # plugins.connect(fig, PointClickableHTMLTooltip(scat, labels=labels, targets=targets)) # mpld3.save_html(fig, "mpld3-newtab.html") import matplotlib.pyplot as plt, mpld3 import numpy as np from mpld3 import fig_to_html, plugins N_paths = 5 N_steps = 100 x = np.linspace(0, 10, 100) y = 0.1 * (np.random.random((N_paths, N_steps)) - 0.5) y = y.cumsum(1) fig, ax = plt.subplots() labels = ["a", "b", "c", "d", "e"] line_collections = ax.plot(x, y.T, lw=4, alpha=0.6) interactive_legend = plugins.InteractiveLegendPlugin(line_collections, labels, alpha_unsel=0.2, alpha_over=1.5, start_visible=True) plugins.connect(fig, interactive_legend) mpld3.save_html(fig, "mpld3-filter.html")
N = 100 df = pd.DataFrame((.1 * (np.random.random((N, 5)) - .5)).cumsum(0), columns=['a', 'b', 'c', 'd', 'e'],) # plot line + confidence interval fig, ax = plt.subplots() ax.grid(True, alpha=0.3) for key, val in df.iteritems(): l, = ax.plot(val.index, val.values, label=key) ax.fill_between(val.index, val.values * .5, val.values * 1.5, color=l.get_color(), alpha=.4) # define interactive legend handles, labels = ax.get_legend_handles_labels() # return lines and labels interactive_legend = plugins.InteractiveLegendPlugin(zip(handles, ax.collections), labels, alpha_unsel=0.5, alpha_over=1.5, start_visible=True) plugins.connect(fig, interactive_legend) ax.set_xlabel('x') ax.set_ylabel('y') ax.set_title('Interactive legend', size=20) # mpld3.show()
def line_per_cmd(args): import matplotlib if args.output is not None: matplotlib.use('Agg') # We need this to make matplotlib work on systems with no DISPLAY import matplotlib.pyplot as plt import pylab matplotlib.rcParams.update({'figure.subplot.right': args.plot_size}) matplotlib.rcParams.update({'figure.subplot.bottom': args.plot_size}) plt.style.use(args.pyplot_style) # First we create `means` which map a command label and date to a pair of mean and standard deviation # e.g. means['Bean']['2017-05-02 13:29:34.87'] = (0.1289, 0.0006) (means, cmd_labels, meta_keys) = util.means_series_map(args) # Let's write a plot line for each command label fig, ax = plt.subplots() lines = [] for cmd_label in cmd_labels: x, y, err = ([], [], []) for i in range(len(meta_keys)): (mean, std) = means[cmd_label].get(meta_keys[i], (0, 0)) x.append(i) y.append(mean) err.append(std) lines.append(ax.errorbar(x, y, fmt='-o', yerr=err)) if args.ymin is not None: plt.ylim(ymin=float(args.ymin)) if args.ymax is not None: plt.ylim(ymax=float(args.ymax)) if args.title is not None: plt.title(util.texsafe(args.title)) # Add some text for labels, title and axes ticks ax.set_xticks(range(len(meta_keys))) ax.set_xticklabels(meta_keys, rotation=args.xticklabel_rotation) if not args.no_legend and not args.mpld3: # mpld3 comes with its own legends ax.legend(lines, cmd_labels, loc='best', fancybox=True, shadow=True) if args.mpld3: import mpld3 from mpld3 import plugins interactive_legend = plugins.InteractiveLegendPlugin(lines, cmd_labels) plugins.connect(fig, interactive_legend) if args.output is not None: fname = args.output.name fformat = fname.split('.')[-1] print ("Writing file '%s' using format '%s'." % (fname, fformat)) if args.mpld3: if fformat == "html": mpld3.save_html(fig, args.output) elif fformat == "json": mpld3.save_json(fig, args.output) else: raise ValueError("--mpld3: The output must be either `html` or `json`") else: pylab.savefig(args.output, format=fformat) else: if args.mpld3: mpld3.show() else: pylab.show()