def parseAndGenerateImage(self, script_string): input = InputStream(script_string) lexer = PigeonLexer(input) stream = CommonTokenStream(lexer) parser = PigeonParser(stream) tree = parser.script() htmlPigeon = HtmlPigeonListener() walker = ParseTreeWalker() walker.walk(htmlPigeon, tree) dr = dpl.DNARenderer() part_renderers = dr.SBOL_part_renderers() design = HtmlPigeonListener.getDesignList(htmlPigeon) arcs = HtmlPigeonListener.getArcList(htmlPigeon) fig = plt.figure(figsize=(design.__len__() / 3, 2)) gs = gridspec.GridSpec(1, 1) axis = plt.subplot(gs[0]) print("Deisgn Length: " + str(design.__len__())) print("Arcs Length: " + str(arcs.__len__())) start, end = dr.renderDNA(axis, design, part_renderers, regs=arcs, reg_renderers=dr.std_reg_renderers()) axis.set_xlim([start, end]) axis.set_ylim([-(30 + design.__len__()), (30 + design.__len__())]) axis.set_aspect('equal') axis.axis('off') self.fig = fig pass
def plot_operon_structure(design, fig_width, directory_name=""): # Redender the DNA fig = plt.figure(figsize=(fig_width / 85, 0.5)) gs = gridspec.GridSpec(1, 1) ax_dna = plt.subplot(gs[0]) dr = dpl.DNARenderer() part_renderers = dr.SBOL_part_renderers() start, end = dr.renderDNA(ax_dna, design, part_renderers) # Set bounds and display options for the DNA axis dna_len = end - start ax_dna.set_xlim([start - 20, end + 20]) ax_dna.set_ylim([-15, 20]) ax_dna.plot([start - 20, end + 20], [0, 0], color=(0, 0, 0), linewidth=1.0, zorder=1) ax_dna.axis('off') plt.subplots_adjust(hspace=.08, left=.01, right=.99, top=0.99, bottom=0.02) #create the directory if it doesn't exist if not path.exists(directory_name): os.makedirs(directory_name, exist_ok=True) #remember to add mode later plt.savefig("{}sbol_plot".format(directory_name), dpi=300) plt.close('all')
def plotDesign(design,renderer = None,part_renderers=None,\ circular=False,title=None): """helper function for doing dnaplotlib plots. You need to set the size and min max of the plot, and that's what this function does""" if (PLOT_DNA): if (renderer is None): renderer = dpl.DNARenderer(scale=5, linewidth=3) if (part_renderers is None): part_renderers = renderer.SBOL_part_renderers() fig = plt.figure(figsize=(len(design) * .75, 1.1)) ax = fig.add_axes([0, 0, 1, 1]) try: start, end = renderer.renderDNA(ax, design, part_renderers, circular=circular) except TypeError: start, end = renderer.renderDNA(ax, design, part_renderers) ax.axis('off') if title is not None: ax.set_title(title) addedsize = 1 ax.set_xlim([start - addedsize, end + addedsize]) ax.set_ylim([-15, 15]) plt.show() else: warn( "plotting DNA has been disabled because you don't have DNAplotlib")
def Run_PlotCircuit(Input, Regulations=None): dr = dpl.DNARenderer() ## Parse the command line inputs #parser = argparse.ArgumentParser(description="one line quick plot") #parser.add_argument("-input", dest="input", required=True, help="\"p.orange p.lightblue i.lightred r.green c.orange t.purple -t.black -c.yellow -p.yellow\"", metavar="string") #parser.add_argument("-output", dest="output", required=False, help="output pdf filename") #args = parser.parse_args() # Input = "p.black.pBAD r.black.rbsD c.red.RFP t.black -t.black.BBaB0015 -c.green.GFP -r.black.rbs34 -i.black -p.black.pTet o.black.CoIE1" #print('Hello: ', args.input) # Process the arguments design = PlotCircuitfunc(Input) reg_renderers = dr.std_reg_renderers() part_renderers = dr.SBOL_part_renderers() #Regulations = None # For adding regulation control (Activation, Repression, Connection) # Regulations = [{'type': 'Repression', 'from_part': {'start': 40, 'end': 40}, # 'to_part': {'start': 150,'end': 150, 'fwd': True}, # 'opts': {'color': (0.12,0.47,0.71), 'linewidth': 1.5}}] # Generate the figure fig = plt.figure(figsize=(1.0, 1.0), dpi=100) ax = fig.add_subplot(1, 1, 1) # Plot the design dna_start, dna_end = dr.renderDNA(ax, design, part_renderers, Regulations, reg_renderers) max_dna_len = dna_end - dna_start print('Max Dna length: ', max_dna_len) # Format the axis ax.set_xticks([]) ax.set_yticks([]) # Set bounds ax.set_xlim([(-0.0 * max_dna_len), max_dna_len + (0.0 * max_dna_len)]) ax.set_ylim([-25, 25]) ax.set_aspect('equal') ax.set_axis_off() # Update the size of the figure to fit the constructs drawn fig_x_dim = max_dna_len / 30 #/60.0 print('x_dim: ', fig_x_dim) if fig_x_dim < 1.0: fig_x_dim = 1.0 fig_y_dim = 1.8 #fig_x_dim*0.4 plt.gcf().set_size_inches(fig_x_dim, fig_y_dim, forward=True) # Save the figure plt.tight_layout() #fig.savefig(args.output, transparent=True) plt.show()
def plot_nupop(design_nupop, full_sequence, directory_name=""): #wrap promoter with 420bp buffer sequence on each side pre = "aaaagactctaacaaaatagcaaatttcgtcaaaaatgctaagaaataggttattactgagtagtatttatttaagtattgtttgtgcacttgcctgcaagccttttgaaaagcaagcataaaagatctaaacataaaatctgtaaaataacaagatgtaaagataatgctaaatcatttggctttttgattgattgtacaggaaaatatacatcgcagggggttgacttttaccatttcaccgcaatggaatcaaacttgttgaagagaatgttcacaggcgcatacgctacaatgacccgattcttgctagccgaattccagtcaggctgctagcaccagagctacgtgaccgcaggactagctccagctgagcgacacgcgaacaggtgtagagtcagtcgtgctgcaaggtcgcac" post = "TTAAAGAGGAGAAAGGTACCATGAGTAAAGGAGAAGAACTTTTCACTGGAGTTGTCCCAATTCTTGTTGAATTAGATGGTGATGTTAATGGGCACAAATTTTCTGTCAGTGGAGAGGGTGAAGGTGATGCAACATACGGAAAACTTACCCTTAAATTTATTTGCACTACTGGAAAACTACCTGTTCCATGGCCAACACTTGTCACTACTTTCACTTATGGTGTTCAATGCTTTTCAAGATACCCAGATCATATGAAACGGCATGACTTTTTCAAGAGTGCCATGCCCGAAGGTTATGTACAGGAAAGAACTATATTTTTCAAAGATGACGGGAACTACAAGACACGTGCTGAAGTCAAGTTTGAAGGTGATACCCTTGTTAATAGAATCGAGTTAAAAGGTATTGATTTTAAAGAAGATG" buffered_sequence = pre + full_sequence + post #run NuPoP on R NuPoP_out = subprocess.check_output( ["Rscript", "NuPoP_Rscript.R", buffered_sequence]) nuc_occu = NuPoP_out.decode("utf-8").split() nuc_occu = list(map(float, nuc_occu)) operon_length = len(full_sequence) # Create the figure and all axes to draw to (width of figure should be size of operon divided by 200) fig = plt.figure(figsize=(operon_length / 400, 1.5)) gs = gridspec.GridSpec(2, 1, height_ratios=[0.5, 0.3]) ax_dna = plt.subplot(gs[0]) # Render the DNA dr = dpl.DNARenderer(scale=1, linewidth=0.9) start, end = dr.renderDNA(ax_dna, design_nupop, dr.trace_part_renderers()) # Set bounds and display options for the DNA axis ax_dna.set_xlim([0, operon_length]) ax_dna.set_ylim([-8, 8]) ax_dna.plot([0, operon_length], [0, 0], color=(0, 0, 0), linewidth=1.0, zorder=1) ax_dna.axis('off') #plot the NuPoP output nuc_coords = range(-420, operon_length + 420) ax_nupop = plt.subplot(gs[1]) ax_nupop.plot(nuc_coords, nuc_occu, linewidth=1) ax_nupop.set_xlim([0, operon_length]) ax_nupop.set_ylim([0, 1.1]) ax_nupop.set_xlabel('Nucleotide Position', fontsize=8, labelpad=6) ax_nupop.spines["top"].set_visible(False) #ax.spines["bottom"].set_visible(False) ax_nupop.spines["right"].set_visible(False) #ax.spines["left"].set_visible(False) ax_nupop.tick_params(axis='y', which='major', pad=2, labelsize=8) ax_nupop.tick_params(axis='x', which='major', pad=2, labelsize=8) plt.setp(ax_nupop.spines.values(), linewidth=1) plt.fill_between(nuc_coords, nuc_occu, color=(0.38, 0.65, 0.87)) plt.subplots_adjust(hspace=.08, left=.03, right=.99, top=0.99, bottom=0.30) #create the directory if it doesn't exist if not path.exists(directory_name): os.makedirs(directory_name, exist_ok=True) #remember to add mode later plt.savefig("{}nupop_plot".format(directory_name), dpi=300)
def main(): # Parse the command line inputs parser = argparse.ArgumentParser(description="one line quick plot") parser.add_argument( "-input", dest="input", required=True, help= "\"p.gray p.lightblue i.lightred r.green c.orange t.purple -t.black -c.yellow -p.yellow\"", metavar="string") parser.add_argument("-output", dest="output", required=False, help="output pdf filename") args = parser.parse_args() # Process the arguments design = process_arguments(args.input) # Create objects for plotting (dnaplotlib) dr = dpl.DNARenderer(linewidth=1.15, backbone_pad_left=3, backbone_pad_right=3) reg_renderers = dr.std_reg_renderers() part_renderers = dr.SBOL_part_renderers() regs = None # Generate the figure fig = plt.figure(figsize=(5.0, 5.0)) ax = fig.add_subplot(1, 1, 1) # Plot the design dna_start, dna_end = dr.renderDNA(ax, design, part_renderers, regs, reg_renderers) max_dna_len = dna_end - dna_start # Format the axis ax.set_xticks([]) ax.set_yticks([]) # Set bounds ax.set_xlim([(-0.01 * max_dna_len), max_dna_len + (0.01 * max_dna_len)]) ax.set_ylim([-35, 35]) ax.set_aspect('equal') ax.set_axis_off() # Update the size of the figure to fit the constructs drawn fig_x_dim = max_dna_len / 60.0 if fig_x_dim < 1.0: fig_x_dim = 1.0 fig_y_dim = 1.2 plt.gcf().set_size_inches((fig_x_dim, fig_y_dim)) # Save the figure plt.tight_layout() fig.savefig(args.output, transparent=True, dpi=300)
def PlotCircuit(self, filename, Input, Regulation=None): """Plot the SBOL-compliant gene circuit figure. Parameters: filename: the filename for the generated figure Input, Regulation: Input design and Regulation strings from users Returns: Max DNA Design length and export the gene circuit figure """ # matplotlib.use("Qt5Agg") matplotlib.use("Agg") dr = dpl.DNARenderer(linewidth=1.5) # Process the arguments design, Regulations = self.CircuitDesign(Input, Regulation) reg_renderers = dr.std_reg_renderers() part_renderers = dr.SBOL_part_renderers() # Generate the figure fig = plt.figure(figsize=(1.0, 1.0), dpi=100) ax = fig.add_subplot(1, 1, 1) # Plot the design dna_start, dna_end = dr.renderDNA(ax, design, part_renderers, Regulations, reg_renderers) max_dna_len = dna_end - dna_start # print("Max Dna length: ", max_dna_len) # Format the axis ax.set_xticks([]) ax.set_yticks([]) # Set bounds ax.set_xlim([(-0.0 * max_dna_len), max_dna_len + (0.0 * max_dna_len)]) ax.set_ylim([-25, 25]) ax.set_aspect("equal") ax.set_axis_off() # Update the size of the figure to fit the constructs drawn fig_x_dim = max_dna_len / 30 # print("x_dim: ", fig_x_dim) if fig_x_dim < 1.0: fig_x_dim = 1.0 fig_y_dim = 1.8 plt.gcf().set_size_inches(fig_x_dim, fig_y_dim, forward=True) # Save the figure plt.tight_layout() fig.savefig(filename, transparent=True, dpi=300) # plt.show() return max_dna_len, fig
def plot_trace_y_offset(designs, output_prefix): design_frame1 = designs[0] design_frame2 = designs[1] design_frame3 = designs[2] # Generate the offsets for each design frame2_offset = 9.0 for part in design_frame2: if 'opts' in list(part.keys()): part['opts']['y_offset'] = frame2_offset else: part['opts'] = {'y_offset': frame2_offset} frame3_offset = 16.0 for part in design_frame3: if 'opts' in list(part.keys()): part['opts']['y_offset'] = frame3_offset else: part['opts'] = {'y_offset': frame3_offset} # We can now combine all into a single design combined_designs = design_frame1 + design_frame2 + design_frame3 # Create the figure and all axes to draw to fig = plt.figure(figsize=(3.2, 1.2)) gs = gridspec.GridSpec(1, 1) ax_dna_all_frames = plt.subplot(gs[0]) # Redender the DNA dr = dpl.DNARenderer(scale=5, linewidth=0.9) start1, end1 = dr.renderDNA(ax_dna_all_frames, combined_designs, dr.trace_part_renderers(), plot_backbone=True) # We specify the length manually as we know the design constraints start1 = 0 end1 = 2640 dna_len = end1 - start1 ax_dna_all_frames.set_xlim([start1 - 20, end1 + 20]) ax_dna_all_frames.set_ylim([-5, 21]) # We also plot a manual backbone beyond the extent of the design ax_dna_all_frames.plot([start1 - 20, end1 + 20], [0, 0], color=(0, 0, 0), linewidth=1.0, zorder=1) ax_dna_all_frames.axis('off') plt.subplots_adjust(hspace=.001, left=.01, right=.99, top=0.99, bottom=0.01) # Save the figure fig.savefig(output_prefix + '.pdf', transparent=True) fig.savefig(output_prefix + '.png', dpi=300) # Clear the plotting cache plt.close('all')
def main(): parser = argparse.ArgumentParser( description="Plot RNAseq profile from predicted RPU." ) parser.add_argument("--ucf", "-u", required=True, help="UCF file.", metavar="FILE") parser.add_argument("--netlist", "-n", required=True, help="Netlist.", metavar="FILE") parser.add_argument("--output", "-o", required=False, help="Output file.", metavar="FILE") args = parser.parse_args() with open(args.ucf, 'r') as ucf_file: ucf = pycello2.ucf.UCF(json.load(ucf_file)) with open(args.netlist, 'r') as netlist_file: netlist = pycello2.netlist.Netlist(json.load(netlist_file), ucf) designs = pycello2.dnaplotlib.get_designs(netlist) fig = plt.figure(figsize=(5, len(designs)*1)) h_frac = 1./len(designs) w_pad = 0.05 for i, design in enumerate(designs): width = (1. - w_pad*(len(design) - 1)) left = 0.0 seq_len = 0 for group in design: seq_len += group[-1]['end'] for j, group in enumerate(design): w_frac = group[-1]['end'] / seq_len * width # Set up the axes for the genetic constructs rect = [left, i*h_frac, w_frac, h_frac] left += w_frac + w_pad ax = fig.add_axes(rect) # Create the DNAplotlib renderer dr = dpl.DNARenderer() # Redender the DNA to axis start, end = dr.renderDNA(ax, group, dr.trace_part_renderers()) ax.set_xlim([start, end]) ax.set_ylim([-5, 10]) ax.set_aspect('auto') ax.set_xticks([]) ax.set_yticks([]) ax.axis('off') if (args.output): out_file = args.output else: out_file = 'out' plt.savefig(out_file + '.png')
def plot_trace_3_axes(designs, output_prefix): design_frame1 = designs[0] design_frame2 = designs[1] design_frame3 = designs[2] # Create the figure and all axes to draw to fig = plt.figure(figsize=(3.2, 1.2)) gs = gridspec.GridSpec(3, 1, height_ratios=[0.5, 0.5, 0.75]) ax_dna_frame1 = plt.subplot(gs[2]) ax_dna_frame2 = plt.subplot(gs[1], sharex=ax_dna_frame1) ax_dna_frame3 = plt.subplot(gs[0], sharex=ax_dna_frame1) # Redender the DNA dr = dpl.DNARenderer(scale=5, linewidth=0.9) start1, end1 = dr.renderDNA(ax_dna_frame1, design_frame1, dr.trace_part_renderers(), plot_backbone=True) dna_len = end1 - start1 ax_dna_frame1.set_xlim([start1 - 20, end1 + 20]) ax_dna_frame1.set_ylim([-3.5, 7]) # We also plot a manual backbone beyond the extent of the design ax_dna_frame1.plot([start1 - 20, end1 + 20], [0, 0], color=(0, 0, 0), linewidth=1.0, zorder=1) ax_dna_frame1.axis('off') start2, end2 = dr.renderDNA(ax_dna_frame2, design_frame2, dr.trace_part_renderers(), plot_backbone=False) ax_dna_frame2.set_ylim([-3.5, 3.5]) ax_dna_frame2.axis('off') start3, end3 = dr.renderDNA(ax_dna_frame3, design_frame3, dr.trace_part_renderers(), plot_backbone=False) ax_dna_frame3.set_ylim([-3.5, 3.5]) ax_dna_frame3.axis('off') plt.subplots_adjust(hspace=.001, left=.01, right=.99, top=0.99, bottom=0.01) # Save the figure fig.savefig(output_prefix + '.pdf', transparent=True) fig.savefig(output_prefix + '.png', dpi=300) # Clear the plotting cache plt.close('all')
def plotConstruct(DNA_construct_obj,dna_renderer=None,\ rna_renderer=None,\ plot_rnas=False,debug=False,showlabels = None,plot_dna_test=True): """helper function for making dnaplotlib plots of a DNA_construct object. Plots the DNAs and the RNAs that come from that DNA, using DNA_construct.explore_txtl""" #TODO: make the label showing more general if (showlabels is None): showlabels = [] if (PLOT_DNA and plot_dna_test): if (dna_renderer is None): dna_renderer = dpl.DNARenderer(scale=5, linewidth=3) if (rna_renderer is None): rna_renderer = dpl.DNARenderer(scale=5, linewidth=3, linecolor=(1, 0, 0)) design = make_dpl_from_construct(DNA_construct_obj, showlabels=showlabels) circular = DNA_construct_obj.circular if (PLOT_DNA and plot_dna_test): plotDesign(design, circular=circular, title=DNA_construct_obj.get_species()) if (plot_rnas): rnas, proteins = DNA_construct_obj.explore_txtl() for promoter in rnas: rnadesign = make_dpl_from_construct(rnas[promoter], showlabels=showlabels) rnacolor = rna_renderer.linecolor for part in rnadesign: if ("edgecolor" not in part['opts']): part['opts'].update({'edgecolor': rnacolor}) plotDesign(rnadesign, renderer=rna_renderer, title=rnas[promoter].get_species()) else: print(DNA_construct_obj.show())
for idx1 in range(len(seq)): for idx2 in range(len(seq)): if h_matrix_60[idx1, idx2] == 1: h_matrix[idx1, idx2] = 60 elif h_matrix_30[idx1, idx2] == 1: h_matrix[idx1, idx2] = 25 elif h_matrix_15[idx1, idx2] == 1: h_matrix[idx1, idx2] = 10 # Create the figure and all axes to draw to fig = plt.figure(figsize=(3.2, 3.4)) gs = gridspec.GridSpec(2, 2, width_ratios=[1, 9], height_ratios=[1.6, 9]) ax_dna_x = plt.subplot(gs[1]) # Redender the DNA dr = dpl.DNARenderer(scale=1, linewidth=0.9) start, end = dr.renderDNA(ax_dna_x, design, dr.trace_part_renderers(), regs=regs, reg_renderers=dr.std_reg_renderers()) # Set bounds and display options for the DNA axis dna_len = end - start ax_dna_x.set_xlim([start, end]) ax_dna_x.set_ylim([-6, 13]) ax_dna_x.plot([start - 20, end + 20], [0, 0], color=(0, 0, 0), linewidth=1.0, zorder=1) ax_dna_x.axis('off')
def visualize(cls, circuit_library, feature_library, min_features): lw = 0.75 dr = dpl.DNARenderer() part_renderers = dr.SBOL_part_renderers() reg_renderers = dr.std_reg_renderers() reg_renderers['CurvedRepression'] = curved_repression reg_renderers['CurvedActivation'] = curved_activation k = 0 for circuit in circuit_library.circuits: if len(circuit.features) > min_features: print('Visualizing ' + circuit.identity) k = k + 1 designs = [] part_dict = {} for feature in circuit.features: comp_definition = feature_library.get_definition( feature.identity) if comp_definition is not None and BIOPAX_DNA in comp_definition.types: design = [] located = [] for seq_anno in comp_definition.sequenceAnnotations: if seq_anno.component is not None and len( seq_anno.locations ) == 1 and seq_anno.locations[0].getTypeURI( ) == SBOL_RANGE: sub_comp = comp_definition.components.get( seq_anno.component) range_location = seq_anno.locations.getRange() located.append( (range_location.start, range_location.end, range_location.orientation, sub_comp.definition, sub_comp.identity)) located.sort() max_span = 1 for i in range(1, len(located)): span = located[i][0] - located[i - 1][1] if span > max_span: max_span = span for i in range(0, len(located)): if i > 0: span = located[i][0] - located[i - 1][1] if span > 0: normal_span = int(span / max_span * 60) else: normal_span = 0 if normal_span > 0: design.append({ 'type': 'EmptySpace', 'fwd': True, 'opts': { 'x_extent': normal_span } }) feature_definition = feature_library.get_definition( located[i][3]) part = {'opts': {}} for role in feature_definition.roles: if role in cls.SO_DICT: part['type'] = cls.SO_DICT[role] elif 'type' not in part: part['type'] = 'UserDefined' if part['type'] == 'CDS': part['opts']['arrowhead_height'] = 0 part['name'] = located[i][4] if part['type'] == 'CDS' or part[ 'type'] == 'promoter': if feature_definition.name is None: part['opts'][ 'label'] = feature_definition.displayId else: part['opts'][ 'label'] = feature_definition.name part['opts']['label_y_offset'] = -30 part['opts']['label_size'] = 4 if part['type'] == 'CDS': part['opts']['label_style'] = 'italic' part['fwd'] = ( located[i][2] == SBOL_ORIENTATION_INLINE) if located[i][3] not in part_dict: part_dict[located[i][3]] = [] part_dict[located[i][3]].append(part) design.append(part) designs.append(design) arcs = [] for template in circuit.get_feature_identities(): for activated in circuit_library.get_activated_by_template( template): for source in part_dict[template]: for sink in part_dict[activated]: arcs.append({ 'type': 'CurvedActivation', 'from_part': source, 'to_part': sink, 'opts': { 'color': cls.COLOR['green'], 'linewidth': lw, 'arc_height_start': 15, 'arc_height_end': 15, 'rad': -0.4 } }) for repressed in circuit_library.get_repressed_by_template( template): for source in part_dict[template]: for sink in part_dict[repressed]: arcs.append({ 'type': 'CurvedRepression', 'from_part': source, 'to_part': sink, 'opts': { 'color': cls.COLOR['red'], 'linewidth': lw, 'arc_height_start': 15, 'arc_height_end': 15, 'rad': -0.4 } }) fig = plt.figure(figsize=(2.2, 1.8)) gs = gridspec.GridSpec(len(designs), 1) dna_axes = [] for i in range(0, len(designs)): dna_axes.append(plt.subplot(gs[i])) for i in range(0, len(designs)): dna_axis = plt.subplot(gs[i]) start, end = dr.renderDNA(dna_axis, designs[i], part_renderers, regs=arcs, reg_renderers=reg_renderers) # start, end = dr.renderDNA(ax_dna1, design1, part_renderers, regs=reg1, reg_renderers=reg_renderers) dna_axis.set_xlim([start, end]) dna_axis.set_ylim([-25, 25]) dna_axis.set_aspect('equal') dna_axis.set_xticks([]) dna_axis.set_yticks([]) dna_axis.axis('off') plt.subplots_adjust(hspace=0.01, left=0.05, right=0.95, top=0.92, bottom=0.01) fig.savefig('test_circuit' + str(k) + '.pdf', transparent=True) fig.savefig('test_circuit' + str(k) + '.png', dpi=300) plt.close('all') logging.info('Finished visualizing %s.\n', circuit.identity) else: logging.warning('Failed to visualize %s.\n', circuit.identity)
def plot_sequence(seq=None, seq_name=None, start_position=None, end_position=None, seq_label=None, seq_label_pos='left', glyph_labels={}, ignore_names=[], cds_split_char='', cds_colors={}, cds_label_colors={}, chromosomal_locus=None, chromosomal_locus_pos='left', ax=None, ax_x_extent=250, ax_x_alignment='center', ax_ylim=(-15, 15), savefig=None): """ Plot a specified benchling sequence as SBOL visual Parameters ---------- seq : benchlingclient.DNASequence Sequence to be plotted. Can be omitted if `seq_name` is provided. seq_name : str, optional Name of the sequence to load and plot. Ignored if `seq` is specified. start_position, end_position : int, optional Only annotations in the sequence completely contained by the range given by these two parameters will be plotted. seq_label : str, optional If specified, the text specified in `seq_label` will be added to either the left or right side of the sequence diagram, depending on the contents of `seq_label_pos`. seq_label_pos : {'left', 'right'}, optional Whether to add the label in `seq_label` to the left or right side of the sequence diagram. glyph_labels : dict, optional Dictionary with ``name: label`` pairs that specify a glyph's label, when the label is different than the name. If a part's name is not a key of `glyph_labels`, the name will be used as the glyph's label. ignore_names : list, optional Names of parts that should not be plotted. cds_split_char : str, optionsl If specified, a CDS whose name contains `cds_split_char` as a substring will be split along this substring and shown as a multipart CDS. A multipart CDS looks like a single CDS divided into many fragments, each with its own label and color that can be specified in `glyph_labels`, `cds_colors`, and `cds_label_colors`. cds_colors : dict, optional Dictionary with ``name: color`` pairs that specify a CDS' face color, when the color is different than the one specified by ``RENDER_OPT['CDS']``. cds_label_colors : dict, optional Dictionary with ``name: label_color`` pairs that specify a CDS' label color, when the color is different than the one specified by ``RENDER_OPT['CDS']``. chromosomal_locus : str, optional If specified, a pair of "ChromosomalLocus" glyphs will be added to both sides of the rendered design, and a label with the text given by `chromosomal_locus` on the glyph specified by `chromosomal_locus_pos`. chromosomal_locus_pos : {'left', 'right', 'both', 'none'}, optional Location of the chromosomal locus label. ax : matplotlib.axes, optional Axes to draw into. ax_x_extent : float, optinal Range covered by the x axis limits. ax_x_alignment : {'left', 'center', 'right'} Alignment of the rendered diagram in the x axis. ax_ylim : tuple-like, optional Y axis limits. savefig : str, optional If specified, save figure with a filename given by `savefig`. Raises ------ ValueError If more than one sequence with the name given by `seq_name` was found. """ # If seq is provided, the following is not executed. # If not, load from seq_name if seq is None: if seq_name is not None: # Load sequence from benchling seq_list = benchlingclient.DNASequence.list_all(name=seq_name) # Test that only one sequence has been found if len(seq_list) > 1: raise ValueError("more than one sequence found with name {}".\ format(seq_name)) elif len(seq_list) < 1: raise ValueError("no sequence with name {} found".\ format(seq_name)) seq = seq_list[0] else: # No sequence or sequence name provided, raise exception raise ValueError("seq or seq_name should be provided") # Get annotations annotations = seq.annotations.copy() # Remove annotations outside of range specified if start_position is None: start_position = 0 if end_position is None: end_position = seq.length - 1 annotations_filtered = [] for annotation in annotations: if (annotation.start >= start_position) and \ (annotation.end <= end_position): annotations_filtered.append(annotation) annotations = annotations_filtered # Sort by start position annotations = sorted(annotations, key=lambda x: x.start) # Initialize plot if ax is None: fig, ax = pyplot.subplots() # Set axis limits and aspect right away # This allows for a more precise estimation of label widths later on ax.set_xlim((0, ax_x_extent)) ax.set_ylim(ax_ylim) ax.set_aspect('equal') # Iterate and extract parts to be plotted parts = [] for annotation in annotations: # Iterate through mapping and select appropriate part type match = False for mapping in ANN_PARTS_MAPPING: if check_annotation_features(annotation, mapping['annotation']): match = True break # Only add part if matching part has been found if match: part_type = mapping['part'] part_name = annotation.name # Part will be split if type is CDS and a cds_split_char has been # specified. # All resulting parts, but the last one, will be given the temporary # part type "CDSFragment". This is so arrowheads and padding are # modified later to make a continuous multipart CDS glyph. if cds_split_char and mapping['part'] == 'CDS': part_names = part_name.split(cds_split_char) # Remove parts flagged to be ignored part_names = [p for p in part_names if p not in ignore_names] if len(part_names) == 0: continue # Reverse if orientation is reverse if annotation.strand == -1: part_names = part_names[::-1] for part_index, part_name in enumerate(part_names): # Define new part part = {} if annotation.strand == -1: if part_index <= 0: part['type'] = 'CDS' else: part['type'] = 'CDSFragment' else: if part_index < (len(part_names) - 1): part['type'] = 'CDSFragment' else: part['type'] = 'CDS' part['name'] = part_name # Orientation ('fwd') will be False if the reverse strand is # explicitly specified in the annotation, True if any other # value, not specified if None. if annotation.strand is not None: part['fwd'] = not (annotation.strand == -1) # Save part parts.append(part) else: # Check if part name is flagged to be ignored if part_name in ignore_names: continue # Define new part part = {} part['type'] = part_type part['name'] = part_name # Orientation ('fwd') will be False if the reverse strand is # explicitly specified in the annotation, True if any other # value, not specified if None. if annotation.strand is not None: part['fwd'] = not (annotation.strand == -1) # Save part parts.append(part) # Construct plotting options for each part for part_index, part in enumerate(parts): # Initialize dictionary with rendering options opts = {} # GENERAL TYPE-DEPENDENT RENDERING OPTIONS # ======================================== # Get opts from RENDER_OPT if available if part['type'] == 'CDSFragment': # CDSFragment combines options from 'CDS' and 'CDSFragment', with # the latter taking precedence. part_type_opts = RENDER_OPT.get('CDSFragment', {}) part_type_opts_cds = RENDER_OPT.get('CDS', {}) for k, v in part_type_opts_cds.items(): if k not in part_type_opts: part_type_opts[k] = v else: part_type_opts = RENDER_OPT.get(part['type'], {}) # PART-SPECIFIC RENDERING OPTIONS # =============================== # The following deals with issues specific to the type "CDSFragment" # 'CDSFragment' does not have an arrowhead if part['type'] == 'CDSFragment': opts['arrowhead_length'] = 0 opts['arrowhead_height'] = 0 # Correction for label_x_offset # Removing padding will affect how the CDS looks but not the label, # therefore the label offset has to be corrected. label_x_offset_c = 0 if ('fwd' in part) and (part['fwd'] == False): # Start padding is zero if there is a 'CDS' or CDSFragment' to the # left if part['type'] == 'CDSFragment': if (part_index > 0) and \ (parts[part_index-1]['type'] in ['CDS', 'CDSFragment']): opts['end_pad'] = 0 label_x_offset_c += part_type_opts.get('end_pad', 0) / 2 # End padding is zero if there is a 'CDSFragment' to the right if part['type'] in ['CDS', 'CDSFragment']: if (part_index < (len(parts)-1)) and \ (parts[part_index+1]['type']=='CDSFragment'): opts['start_pad'] = 0 label_x_offset_c -= part_type_opts.get('start_pad', 0) / 2 else: # Start padding is zero if there is a 'CDSFragment' to the left if part['type'] in ['CDS', 'CDSFragment']: if (part_index > 0) and \ (parts[part_index-1]['type']=='CDSFragment'): opts['start_pad'] = 0 label_x_offset_c -= part_type_opts.get('start_pad', 0) / 2 # End padding is zero if there is a 'CDS' or 'CDSFragment' to the # right if part['type'] == 'CDSFragment': if (part_index < (len(parts)-1)) and \ (parts[part_index+1]['type'] in ['CDS', 'CDSFragment']): opts['end_pad'] = 0 label_x_offset_c += part_type_opts.get('end_pad', 0) / 2 # Colors for CDS glyph and label if part['type'] in ['CDS', 'CDSFragment']: if part['name'] in cds_colors: opts['color'] = cds_colors[part['name']] if part['name'] in cds_label_colors: opts['label_color'] = cds_label_colors[part['name']] # Some elements in RENDER_OPT can be functions, in which case the # actual value is computed by calling that function with the label width # as an argument. # Label is taken from the glyph_labels dictionary, or from the name. label = glyph_labels.get(part['name'], part['name']) opts['label'] = label # Method to calculate label_width from "https://stackoverflow.com/\ # questions/24581194/matplotlib-text-bounding-box-dimensions" t = ax.text(0, 0, label, fontsize=part_type_opts.get('label_size', 7), fontstyle=part_type_opts.get('label_style', 'normal')) bb = t.get_window_extent(renderer=ax.figure.canvas.get_renderer()) bb_datacoords = bb.transformed(ax.transData.inverted()) label_width = bb_datacoords.width t.remove() # Iterate over options for k, v in part_type_opts.items(): if k in opts: # Don't override specific options established above continue elif hasattr(v, '__call__'): # Evaluate option based on label width opts[k] = v(label_width) else: # Special case: label_y_offset is modified depending on the # orientation of the part if k == 'label_y_offset': if ('fwd' in part) and (not part['fwd']): opts[k] = -v else: opts[k] = v # Special case: label_x_offset is modified depending on the # orientation of the part and an offset correction elif k == 'label_x_offset': if ('fwd' in part) and (not part['fwd']): opts[k] = -(v + label_x_offset_c) else: opts[k] = v + label_x_offset_c else: opts[k] = v # Add options part['opts'] = opts # 'CDSFragment' is not a real dnaplotlib part type. Change it to 'CDS' for part in parts: if part['type'] == 'CDSFragment': part['type'] = 'CDS' # Define renderer options sequence_opts = RENDER_OPT.get('Sequence', {}) backbone_linewidth = sequence_opts.get('backbone_linewidth', 1) if chromosomal_locus is not None: backbone_pad_left = -2 * backbone_linewidth backbone_pad_right = -2 * backbone_linewidth else: backbone_pad_left = 0 backbone_pad_right = 0 # Add chromosomal locus parts if specified if chromosomal_locus is not None: # 5' glyph cl5 = {} cl5['type'] = '5ChromosomalLocus' cl5['name'] = 'cl5_{}'.format(chromosomal_locus) cl5['fwd'] = True opts = RENDER_OPT.get('5ChromosomalLocus', {}).copy() if chromosomal_locus_pos in ['left', 'both']: opts['label'] = chromosomal_locus opts['linewidth'] = backbone_linewidth cl5['opts'] = opts # 3' glyph cl3 = {} cl3['type'] = '3ChromosomalLocus' cl3['name'] = '3cl_{}'.format(chromosomal_locus) opts = RENDER_OPT.get('3ChromosomalLocus', {}).copy() if chromosomal_locus_pos in ['right', 'both']: opts['label'] = chromosomal_locus opts['linewidth'] = backbone_linewidth cl3['opts'] = opts # Save glyphs parts = [cl5] + parts + [cl3] # Create the DNAplotlib renderer dr = dnaplotlib.DNARenderer( linewidth=backbone_linewidth, backbone_pad_left=backbone_pad_left, backbone_pad_right=backbone_pad_right, ) # Render the DNA to axis start, end = dr.renderDNA(ax, parts, dr.SBOL_part_renderers()) # Add sequence label if specified if seq_label is not None: # Compute offsets seq_label_x_offset = sequence_opts.get('label_x_offset', 0) seq_label_y_offset = sequence_opts.get('label_y_offset', 0) # Compute horizontal position of label if seq_label_pos == 'left': x = start + seq_label_x_offset elif seq_label_pos == 'right': x = end + seq_label_x_offset # Create label t = ax.text( x, seq_label_y_offset, seq_label, fontsize=sequence_opts.get('label_size', 10), horizontalalignment=sequence_opts.get('label_x_alignment', 'left'), verticalalignment='center', zorder=50, ) # Modify 'start' or 'end' depending on label bb = t.get_window_extent(renderer=ax.figure.canvas.get_renderer()) bb_datacoords = bb.transformed(ax.transData.inverted()) start = min(start, bb_datacoords.xmin) end = max(end, bb_datacoords.xmax) # Set x axis limits depending on alignment # Note that the extent is always ax_x_extent if ax_x_alignment == 'left': ax.set_xlim((start, start + ax_x_extent)) if ax_x_alignment == 'right': ax.set_xlim((end - ax_x_extent, end)) if ax_x_alignment == 'center': ax.set_xlim( ((start + end - ax_x_extent) / 2, (start + end + ax_x_extent) / 2)) ax.set_xticks([]) ax.set_yticks([]) ax.axis('off') if savefig is not None: pyplot.savefig(savefig, bbox_inches='tight', dpi=300)
def plot_genome(ax_dna, INI_file): """ General Function that plots a genome from an INI file and puts it into a subplot """ # path to the input files (remove the "params.ini" from the path) path = INI_file.rpartition("/")[0] if path == "": path = "." path += "/" # read the config file config = sim.read_config_file(INI_file) # get inputs infos from the config file GFF_file = path + config.get('INPUTS', 'GFF') TSS_file = path + config.get('INPUTS', 'TSS') TTS_file = path + config.get('INPUTS', 'TTS') Prot_file = path + config.get('INPUTS', 'BARR_FIX') SIGMA_0 = config.getfloat('SIMULATION', 'SIGMA_0') DELTA_X = config.getfloat('GLOBAL', 'DELTA_X') # load and get BARR_FIX positions prot = sim.load_tab_file(Prot_file) BARR_FIX = prot['prot_pos'].values.astype(int) # To draw the beautiful genes we need to read the GFF, TSS and TTS files to get some info ;) gff_df_raw = sim.load_gff(GFF_file) # to get the cov_bp (a verifier) genome_size = sim.get_genome_size(gff_df_raw) genome = math.ceil(genome_size / DELTA_X) cov_bp = np.arange(0, genome_size, DELTA_X) cov_bp = np.resize(cov_bp, genome) gff_df = sim.rename_gff_cols(gff_df_raw) tss = sim.load_tab_file(TSS_file) Kon = tss['TSS_strength'].values tts = sim.load_tab_file(TTS_file) Poff = tts['TTS_proba_off'].values strands = sim.str2num(gff_df['strand'].values) tssstrands = sim.str2num(tss["TUorient"].values) # Color maps for formatting col_map = {} col_map['red'] = (0.95, 0.30, 0.25) col_map['green'] = (0.38, 0.82, 0.32) col_map['blue'] = (0.38, 0.65, 0.87) col_map['orange'] = (1.00, 0.75, 0.17) col_map['purple'] = (0.55, 0.35, 0.64) col_map['yellow'] = (0.98, 0.97, 0.35) col_map['grey'] = (0.70, 0.70, 0.70) col_map['dark_grey'] = (0.60, 0.60, 0.60) col_map['light_grey'] = (0.9, 0.9, 0.9) # CDS formatting options opt_CDSs = [] Ps = [] CDSs = [] Ts = [] design = [] for i in gff_df.index.values: opt_CDSs.append({ #'label': 'Gene%s \n%.03f' % (str(i + 1), Kon[i]), #'label_style': 'italic', #'label_y_offset': -5, #'label_size': 9, 'color': col_map['orange'] }) # Design of the construct if strands[i] == 1: # Coding Sequence CDSs.append({ 'type': 'CDS', 'name': 'CDS%s' % str(i + 1), 'start': gff_df['start'][i], 'end': gff_df['end'][i], 'fwd': gff_df['strand'][i], 'opts': opt_CDSs[i] }) else: # Coding Sequence CDSs.append({ 'type': 'CDS', 'name': 'CDS%s' % str(i + 1), 'start': gff_df['end'][i], 'end': gff_df['start'][i], 'fwd': gff_df['strand'][i], 'opts': opt_CDSs[i] }) # A design is merely a list of parts and their properties if strands[i]: #design.append(Ps[i]) design.append(CDSs[i]) #design.append(Ts[i]) else: #design.append(Ts[i]) design.append(CDSs[i]) #design.append(Ps[i]) for i in tss.index.values: # Design of the construct if tssstrands[i] == 1: # Promoters Ps.append({ 'type': 'Promoter', 'name': 'P%s' % str(i + 1), 'start': tss['TSS_pos'][i], 'end': tss['TSS_pos'][i] + 5, 'fwd': tssstrands[i], 'opts': { 'color': col_map['green'] } }) else: # Promoters Ps.append({ 'type': 'Promoter', 'name': 'P%s' % str(i + 1), 'start': tss['TSS_pos'][i], 'end': tss['TSS_pos'][i] - 5, 'fwd': tssstrands[i], 'opts': { 'color': col_map['green'] } }) # A design is merely a list of parts and their properties design.append(Ps[i]) for i in tts.index.values: print(i) # Terminators Ts.append({ 'type': 'Terminator', 'name': 'T%s' % str(i + 1), 'start': tts['TTS_pos'][i], 'end': tts['TTS_pos'][i] + 5, 'fwd': 1, 'opts': { 'color': col_map['red'] } }) design.append(Ts[i]) # Redender the DNA dr = dpl.DNARenderer(scale=7, linewidth=1) start, end = dr.renderDNA(ax_dna, design, dr.trace_part_renderers()) # Set bounds and display options for the DNA axis dna_len = end - start ax_dna.set_xlim([cov_bp[0], cov_bp[-1]]) # start-50 ax_dna.set_ylim([-8, 8]) # ax_dna.plot(5000, 'ro', markersize=15) for xc in BARR_FIX: ax_dna.axvline(x=xc, ymin=0.40, ymax=0.60, color='k', linewidth=5) ax_dna.plot([cov_bp[0], cov_bp[-1]], [0, 0], color=(0, 0, 0), linewidth=1.0, zorder=1) ax_dna.axis('off') return SIGMA_0, DELTA_X, BARR_FIX, cov_bp
def main(): parser = argparse.ArgumentParser( description="Plot RNAseq profile from predicted RPU.") parser.add_argument("--ucf", "-u", required=True, help="UCF file.", metavar="FILE") parser.add_argument("--activity-table", "-a", dest="activity", required=True, help="Activity table.", metavar="FILE") parser.add_argument("--logic-table", "-l", dest="logic", required=True, help="Logic table.", metavar="FILE") parser.add_argument("--netlist", "-n", required=True, help="Netlist.", metavar="FILE") parser.add_argument("--output", "-o", required=False, help="Output file.", metavar="FILE") parser.add_argument("--debug", "-d", required=False, help="Debug.", action='store_true') args = parser.parse_args() level = logging.DEBUG if args.debug else logging.INFO logging.basicConfig(format='%(levelname)s:%(message)s', level=level) activity = [] logic = [] with open(args.ucf, 'r') as ucf_file: ucf = pycello2.ucf.UCF(json.load(ucf_file)) with open(args.activity, 'r') as activity_file: activity_reader = csv.reader(activity_file) for row in activity_reader: activity.append(row) with open(args.logic, 'r') as logic_file: logic_reader = csv.reader(logic_file) for row in logic_reader: logic.append(row) with open(args.netlist, 'r') as netlist_file: netlist = pycello2.netlist.Netlist(json.load(netlist_file), ucf) # dnaplotlib specifications designs = pycello2.dnaplotlib.get_designs(netlist) placement = netlist.placements[0] num_plots = len(logic[0]) widths = [len(group.sequence) for group in placement.groups] fig = plt.figure(figsize=(np.sum(widths) / 650, num_plots)) gs = fig.add_gridspec(num_plots, len(placement.groups), width_ratios=widths) locator = FixedLocator((1e-5, 1e-3, 1e-1, 1e1, 1e3)) axes = [] for row in range(num_plots - 1): axes_row = [] axes.append(axes_row) for col, group in enumerate(placement.groups): sharex = axes[row - 1][col] if row > 0 else None sharey = axes[0][0] if (row != 0 or col != 0) else None ax = fig.add_subplot(gs[row, col], sharex=sharex, sharey=sharey) axes_row.append(ax) profile = [] temp = [] for component in group.components: for part in component.parts: temp.append(1.0) profile.append(100.0) iteration = 0 while (np.max(np.abs(np.array(profile) - np.array(temp))) > TOLERANCE): format_str = "state: {:>4d} group: {:>4d} iteration: {:>4d}" logging.debug(format_str.format(row, col, iteration)) temp = profile.copy() profile = [] for i, component in enumerate(group.components): for j, part_instance in enumerate(component.parts): # offset to which we add the flux # (readthrough, upstream promoter flux) if j == 0 and i > 0: offset = group.components[i - 1].parts[-1].flux elif j > 0: offset = component.parts[j - 1].flux else: offset = 0.0 if part_instance.part.type == 'promoter': upstream_node = pycello2.utils.get_upstream_node( part_instance.part, component.node, netlist) if upstream_node.type == 'PRIMARY_INPUT': delta_flux = float( get_node_activity(upstream_node, activity)[row]) else: upstream_components = pycello2.utils.get_components( upstream_node, placement) input_flux = 0.0 for upstream_component in upstream_components: input_flux += upstream_component.parts[ -2].flux delta_flux = pycello2.utils.evaluate_equation( upstream_node.gate, {'x': input_flux}) part_instance.flux = pycello2.utils.get_ribozyme( component).efficiency * delta_flux + offset if part_instance.part.type == 'ribozyme': part_instance.flux = offset / pycello2.utils.get_ribozyme( component).efficiency if part_instance.part.type in ('cds', 'rbs'): part_instance.flux = offset if part_instance.part.type == 'terminator': part_instance.flux = offset / part_instance.part.strength profile.append(part_instance.flux) iteration += 1 ax.set_yscale('log') ax.xaxis.set_major_locator(NullLocator()) ax.yaxis.set_major_locator(locator) if col > 0: plt.setp(ax.get_yticklabels(), visible=False) x = [] y = [] last_x = 0 last_y = BASAL_TRANSCRIPTION for i, component in enumerate(group.components): x.append([]) y.append([]) for j, part_instance in enumerate(component.parts): if j == 0: initial_x = last_x initial_y = last_y else: initial_x = x[-1][-1] initial_y = y[-1][-1] if part_instance.part.type == 'terminator': x[-1].append(initial_x) x[-1].append(initial_x + int(0.5 * len(part_instance.part.sequence))) x[-1].append(initial_x + int(0.5 * len(part_instance.part.sequence))) x[-1].append(initial_x + len(part_instance.part.sequence)) y[-1].append(initial_y) y[-1].append(initial_y) y[-1].append(part_instance.flux) y[-1].append(part_instance.flux) elif part_instance.part.type == 'promoter': x[-1].append(initial_x) x[-1].append(initial_x + len(part_instance.part.sequence)) x[-1].append(initial_x + len(part_instance.part.sequence)) y[-1].append(initial_y) y[-1].append(initial_y) y[-1].append(part_instance.flux) elif part_instance.part.type == 'ribozyme': x[-1].append(initial_x) x[-1].append(initial_x + 7) x[-1].append(initial_x + 7) x[-1].append(initial_x + len(part_instance.part.sequence)) y[-1].append(initial_y) y[-1].append(initial_y) y[-1].append(part_instance.flux) y[-1].append(part_instance.flux) else: x[-1].append(initial_x) x[-1].append(initial_x + len(part_instance.part.sequence)) y[-1].append(part_instance.flux) y[-1].append(part_instance.flux) if i == 0: pre_x = [] pre_y = [] else: pre_x = [ last_x, ] pre_y = [ last_y, ] x[-1] = pre_x + x[-1] y[-1] = pre_y + y[-1] last_x = x[-1][-1] last_y = y[-1][-1] for i, component in enumerate(group.components): this_x = np.array(x[i], dtype=np.float64) this_y = np.array(y[i], dtype=np.float64) ax.plot(this_x, this_y, '-', color='black', lw=1) ax.fill_between(this_x, this_y, 1e-10, fc='black', alpha=0.1) ax.set_xlim(x[0][0], x[-1][-1]) ax.set_ylim(1e-4, 1e2) for i, group in enumerate(placement.groups): ax_dna = fig.add_subplot(gs[-1, i]) design = designs[0][i] for part in design: if part['type'] == 'Promoter': part['opts']['x_extent'] = np.sum(widths) / 30 if part['type'] == 'Terminator': part['opts']['x_extent'] = np.sum(widths) / 100 if part['type'] == 'CDS': part['opts']['arrowhead_length'] = np.sum(widths) / 50 part['opts']['y_extent'] = 1 dr = dpl.DNARenderer() start, end = dr.renderDNA(ax_dna, design, dr.trace_part_renderers()) ax_dna.set_xlim([start, end]) ax_dna.set_ylim([-5, 10]) ax_dna.set_aspect('auto') ax_dna.axis('off') label_x = 0.02 label_y = (1.0 + (1.0 / num_plots)) / 2.0 fig.text(label_x, label_y, "predicted transcription (RPU)", va='center', ha='center', rotation='vertical') if (args.output): out_file = args.output else: out_file = 'out' plt.tight_layout(rect=[0.025, 0., 1., 1.]) plt.subplots_adjust(hspace=0.0, wspace=0.1) plt.savefig(out_file + '.png', bbox_to_inches='tight')
def plot(self, circuits, total_gates, total_time, option, num): # Colour map col_map = {} col_map[0] = '#e31414' #red col_map[1] = '#34e681' #green col_map[2] = '#34a4e6' #blue col_map[3] = '#ff7b00' #orange col_map[4] = '#44855a' #dark green col_map[5] = '#1831c4' #dark blue col_map[6] = '#9918c4' #indigo col_map[7] = '#e6178f' #violet col_map[8] = '#995f81' #purple for i in range(len(circuits)): file_num = SortNum(i, option) + 1 if Total_Gates(i) <= total_gates and Total_time( i ) <= total_time and file_num <= num: #If Total Delay and number of gates are less than the input fig = plt.figure() design = [] #A list to be gathered to draw reg = [] #To store the Repression Lines color = 0 #A number to assign colors in order to coordinate with Logical Representation use = [] #To temporarily store the second input of NOR Gate coding_seq = [ ] #A List to temporarily hold coding sequences from each gate seperate = [] for j in range(len(circuits[i])): if j == 0: All_gates = circuits[i][0].split(' ----|') FP = All_gates[-1].split('-> ')[ -1] #YFP for our case right now for k in range(len(All_gates)): gate = All_gates[k].split('-> ') if FP not in gate[-1]: if len(gate) == 2: #NOT Gate if k == 0: #Append all the parts in a list promotor = { 'type': 'Promoter', 'name': gate[0], 'opts': { 'color': (0, 0, 0), 'label': gate[0], 'label_x_offset': -5, 'label_y_offset': -4, 'label_size': 5 } } design.append(promotor) u = { 'type': 'RBS', 'name': 'u' + str(color), 'opts': { 'color': (0, 0, 0), 'start_pad': -6, 'x_extent': 6 } } design.append(u) cds = { 'type': 'CDS', 'name': gate[1], 'opts': { 'color': col_map[color], 'edge_color': col_map[color], 'x_extent': 24, 'label': gate[1], 'label_color': (1, 1, 1), 'label_style': 'italic', 'label_x_offset': -1, 'label_size': 6 } } design.append(cds) coding_seq.append(cds) terminator = { 'type': 'Terminator', 'name': 't' + str(color), 'opts': { 'color': (0, 0, 0), 'start_pad': -1 } } design.append(terminator) else: #If it's not the first gate than it will contain the repression interaction form the previous gate promotor = { 'type': 'Promoter', 'name': gate[0], 'opts': { 'color': col_map[color], 'label': gate[0], 'label_x_offset': -5, 'label_y_offset': -4, 'label_size': 5 } } rep = { 'type': 'Repression', 'from_part': coding_seq[0], 'to_part': promotor, 'opts': { 'color': col_map[color], 'arc_height': 20 } } design.append(promotor) reg.append(rep) coding_seq.pop(0) color += 1 #Change color once the repression intercation is created u = { 'type': 'RBS', 'name': 'u' + str(color), 'opts': { 'color': (0, 0, 0), 'start_pad': -6, 'x_extent': 6 } } design.append(u) cds = { 'type': 'CDS', 'name': gate[1], 'opts': { 'color': col_map[color], 'edge_color': col_map[color], 'x_extent': 24, 'label': gate[1], 'label_color': (1, 1, 1), 'label_style': 'italic', 'label_x_offset': -1, 'label_size': 6 } } design.append(cds) coding_seq.append(cds) terminator = { 'type': 'Terminator', 'name': 't' + str(color), 'opts': { 'color': (0, 0, 0), 'start_pad': -1 } } design.append(terminator) elif len(gate) == 3: #NOR Gate if k == 0: promotor1 = { 'type': 'Promoter', 'name': gate[0], 'opts': { 'color': (0, 0, 0), 'label': gate[0], 'label_x_offset': -6, 'label_y_offset': -4, 'label_size': 5 } } design.append(promotor1) if gate[1] in baseList( ): #If the input is one of PTet, PTac or PBad in our case, the color should be black promotor2 = { 'type': 'Promoter', 'name': gate[1], 'opts': { 'color': (0, 0, 0), 'label': gate[1], 'label_x_offset': -1, 'label_y_offset': -4, 'label_size': 5 } } else: #Other wise tthe color is stored so it can be assigned to its repression promotor2 = { 'type': 'Promoter', 'name': gate[1], 'opts': { 'color': col_map[color], 'label': gate[1], 'label_x_offset': -1, 'label_y_offset': -4, 'label_size': 5 } } use.append((promotor2, color)) color += 1 design.append(promotor2) u = { 'type': 'RBS', 'name': 'u' + str(color), 'opts': { 'color': (0, 0, 0), 'start_pad': -6, 'x_extent': 6 } } design.append(u) cds = { 'type': 'CDS', 'name': gate[2], 'opts': { 'color': col_map[color], 'edge_color': col_map[color], 'x_extent': 24, 'label': gate[2], 'label_color': (1, 1, 1), 'label_style': 'italic', 'label_x_offset': -1, 'label_size': 6 } } design.append(cds) coding_seq.append(cds) terminator = { 'type': 'Terminator', 'name': 't' + str(color), 'opts': { 'color': (0, 0, 0), 'start_pad': -1 } } design.append(terminator) else: promotor1 = { 'type': 'Promoter', 'name': gate[0], 'opts': { 'color': col_map[color], 'label': gate[0], 'label_x_offset': -6, 'label_y_offset': -4, 'label_size': 5 } } rep = { 'type': 'Repression', 'from_part': coding_seq[0], 'to_part': promotor1, 'opts': { 'color': col_map[color], 'arc_height': 20 } } design.append(promotor1) reg.append(rep) coding_seq.pop(0) color += 1 if gate[1] in baseList(): promotor2 = { 'type': 'Promoter', 'name': gate[1], 'opts': { 'color': (0, 0, 0), 'label': gate[1], 'label_x_offset': -1, 'label_y_offset': -4, 'label_size': 5 } } else: promotor2 = { 'type': 'Promoter', 'name': gate[1], 'opts': { 'color': col_map[color], 'label': gate[1], 'label_x_offset': -1, 'label_y_offset': -4, 'label_size': 5 } } use.append((promotor2, color)) color += 1 design.append(promotor2) u = { 'type': 'RBS', 'name': 'u' + str(color), 'opts': { 'color': (0, 0, 0), 'start_pad': -6, 'x_extent': 6 } } design.append(u) cds = { 'type': 'CDS', 'name': gate[2], 'opts': { 'color': col_map[color], 'edge_color': col_map[color], 'x_extent': 24, 'label': gate[2], 'label_color': (1, 1, 1), 'label_style': 'italic', 'label_x_offset': -1, 'label_size': 6 } } design.append(cds) coding_seq.append(cds) terminator = { 'type': 'Terminator', 'name': 't' + str(color), 'opts': { 'color': (0, 0, 0), 'start_pad': -1 } } design.append(terminator) else: if len(gate) == 2: #YFP CDS promotor = { 'type': 'Promoter', 'name': gate[0], 'opts': { 'color': col_map[color], 'label': gate[0], 'label_x_offset': -5, 'label_y_offset': -4, 'label_size': 5 } } rep = { 'type': 'Repression', 'from_part': coding_seq[0], 'to_part': promotor, 'opts': { 'color': col_map[color], 'arc_height': 20 } } design.append(promotor) reg.append(rep) coding_seq.pop(0) color += 1 u = { 'type': 'RBS', 'name': 'u' + str(color), 'opts': { 'color': (0, 0, 0), 'start_pad': -6, 'x_extent': 6 } } design.append(u) cds = { 'type': 'CDS', 'name': gate[1], 'opts': { 'color': (1, 1, 1), 'edge_color': (0, 0, 0), 'x_extent': 24, 'label': gate[1], 'label_color': (0, 0, 0), 'label_style': 'italic', 'label_x_offset': -1, 'label_size': 6 } } design.append(cds) coding_seq.append(cds) terminator = { 'type': 'Terminator', 'name': 't' + str(color), 'opts': { 'color': (0, 0, 0), 'start_pad': -1 } } design.append(terminator) elif len(gate) == 3: #OR Gate for YFP promotor1 = { 'type': 'Promoter1', 'name': gate[0], 'opts': { 'color': col_map[color], 'label': gate[0], 'label_x_offset': -6, 'label_y_offset': -4, 'label_size': 5 } } rep = { 'type': 'Repression', 'from_part': coding_seq[0], 'to_part': promotor1, 'opts': { 'color': col_map[color], 'arc_height': 20 } } design.append(promotor1) reg.append(rep) coding_seq.pop(0) color += 1 if gate[1] in baseList(): promotor2 = { 'type': 'Promoter2', 'name': gate[1], 'opts': { 'color': (0, 0, 0), 'label': gate[1], 'label_x_offset': -1, 'label_y_offset': -4, 'label_size': 5 } } else: promotor2 = { 'type': 'Promoter2', 'name': gate[1], 'opts': { 'color': col_map[color], 'label': gate[1], 'label_x_offset': -1, 'label_y_offset': -4, 'label_size': 5 } } use.append((promotor2, color)) color += 1 design.append(promotor2) u = { 'type': 'RBS', 'name': 'u' + str(color), 'opts': { 'color': (0, 0, 0), 'start_pad': -6, 'x_extent': 6 } } design.append(u) cds = { 'type': 'CDS', 'name': gate[2], 'opts': { 'color': (1, 1, 1), 'edge_color': (0, 0, 0), 'x_extent': 24, 'label': gate[2], 'label_color': (0, 0, 0), 'label_style': 'italic', 'label_x_offset': -1, 'label_size': 6 } } design.append(cds) coding_seq.append(cds) terminator = { 'type': 'Terminator', 'name': 't' + str(color), 'opts': { 'color': (0, 0, 0), 'start_pad': -1 } } design.append(terminator) else: #For the rest of the lines endbracket = len( circuits[i][j]) - circuits[i][j][-1::-1].index(")") All_gates = circuits[i][j][:endbracket].split(' ----|') for k in range(len(All_gates)): gate = All_gates[k].split('-> ') if len(gate) == 2: terminator = { 'type': 'Terminator', 'name': 't' + str(color + 2), 'opts': { 'color': (0, 0, 0), 'start_pad': -1 } } cds_color = use[-1][1] cds = { 'type': 'CDS', 'name': gate[1], 'opts': { 'color': col_map[cds_color], 'edge_color': col_map[cds_color], 'x_extent': 24, 'label': gate[1], 'label_color': (1, 1, 1), 'label_style': 'italic', 'label_x_offset': -1, 'label_size': 6 } } u = { 'type': 'RBS', 'name': 'u' + str(color + 2), 'opts': { 'color': (0, 0, 0), 'start_pad': -6, 'x_extent': 6 } } promotor = { 'type': 'Promoter', 'name': gate[0], 'opts': { 'color': (0, 0, 0), 'label': gate[0], 'label_x_offset': -5, 'label_y_offset': -4, 'label_size': 5 } } arc = { 'type': 'Repression', 'from_part': cds, 'to_part': use[-1][0], 'opts': { 'color': col_map[cds_color], 'arc_height': 35 - (j * 5) } } if j == len( circuits[i] ) - 1: #To avoid intersection of the Repression lines design.insert(0, terminator) design.insert(0, cds) design.insert(0, u) design.insert(0, promotor) else: #Store it temporarily until because it needs to be appended at the end seperate.insert(0, terminator) seperate.insert(0, cds) seperate.insert(0, u) seperate.insert(0, promotor) reg.append(arc) use.pop() design = seperate + design # Set up the axes for the genetic constructs ax_dna = plt.axes() # Create the DNAplotlib renderer dr = dpl.DNARenderer() # Render the DNA to axis start, end = dr.renderDNA(ax_dna, design, dr.SBOL_part_renderers(), regs=reg, reg_renderers=dr.std_reg_renderers()) ax_dna.set_xlim([start, end]) ax_dna.set_ylim([-40, 40]) ax_dna.set_aspect('equal') ax_dna.set_xticks([]) ax_dna.set_yticks([]) ax_dna.axis('off') fig.savefig('user_files/Circuit ' + str(file_num) + ' SBOL Visual.png', dpi=700) plt.close('all')
def computational_device(nb_input, list_integrase, list_gene_state, title, name_directory, dirc_number): # Create the DNAplotlib renderer dr = dpl.DNARenderer() # Use default renderers and append our custom ones for recombinases reg_renderers = dr.std_reg_renderers() reg_renderers['Connection'] = rec.flip_arrow part_renderers = dr.SBOL_part_renderers() part_renderers['RecombinaseSite'] = rec.sbol_recombinase1 part_renderers['RecombinaseSite2'] = rec.sbol_recombinase2 # Create the construct programmably to plot PF = {'type': 'Promoter', 'name': 'prom', 'fwd': True} PR = {'type': 'Promoter', 'name': 'prom', 'fwd': False} Tf = {'type': 'Terminator', 'name': 'term', 'fwd': True} Tr = {'type': 'Terminator', 'name': 'term', 'fwd': False} ##initalization of list # list of attB fwd sites rec_matrix_attB_fwd = [] #list of attP fwd sites rec_matrix_attP_fwd = [] # list of attB rev sites rec_matrix_attB_rev = [] # list of attP fwd sites rec_matrix_attP_rev = [] # list with the full design design = [] # for all nb_input add the corresponding attB and attP site in fwd direction to the corresponding list for X in range(0, nb_input): siteB = ({ 'type': 'RecombinaseSite', 'name': 'Site1', 'fwd': True, 'opts': { 'color': col_map_matrix[list_integrase[X] - 1], 'x_extent': 16, 'y_extent': 12, 'start_pad': 3, 'end_pad': 3 } }) rec_matrix_attB_fwd.append(siteB) siteP = ({ 'type': 'RecombinaseSite', 'name': 'Site1', 'fwd': True, 'opts': { 'color': col_map_matrix[list_integrase[X] - 1], 'x_extent': 16, 'y_extent': 12, 'start_pad': 3, 'end_pad': 3 } }) rec_matrix_attP_fwd.append(siteP) siteB = ({ 'type': 'RecombinaseSite', 'name': 'Site1', 'fwd': False, 'opts': { 'color2': col_map_matrix[list_integrase[X] - 1], 'x_extent': 16, 'y_extent': 12, 'start_pad': 3, 'end_pad': 3 } }) rec_matrix_attB_rev.append(siteB) siteP = ({ 'type': 'RecombinaseSite', 'name': 'Site1', 'fwd': False, 'opts': { 'color2': col_map_matrix[list_integrase[X] - 1], 'x_extent': 16, 'y_extent': 12, 'start_pad': 3, 'end_pad': 3 } }) rec_matrix_attP_rev.append(siteP) # construction for 2 inputs if nb_input == 2: if list_gene_state[2] != 0: design.append(({ 'type': 'CDS', 'name': 'cds', 'fwd': False, 'opts': { 'color': (0.8, 0.8, 0.8), 'label': str(list_gene_state[2]), 'label_x_offset': -2, 'label_y_offset': -0.5, 'label_style': 'italic' } })) design.append(rec_matrix_attB_fwd[1]) design.append(PF) design.append(rec_matrix_attB_fwd[0]) if list_gene_state[0] != 0: design.append(({ 'type': 'CDS', 'name': 'cds', 'fwd': True, 'opts': { 'color': (0.8, 0.8, 0.8), 'label': str(list_gene_state[0]), 'label_x_offset': -2, 'label_y_offset': -0.5, 'label_style': 'italic' } })) design.append(Tf) design.append(Tr) if list_gene_state[1] != 0: design.append(({ 'type': 'CDS', 'name': 'cds', 'fwd': False, 'opts': { 'color': (0.8, 0.8, 0.8), 'label': str(list_gene_state[1]), 'label_x_offset': -2, 'label_y_offset': -0.5, 'label_style': 'italic' } })) design.append(rec_matrix_attP_fwd[1]) design.append(rec_matrix_attP_rev[0]) # construction for 3 inputs elif nb_input == 3: if list_gene_state[3] != 0: design.append(({ 'type': 'CDS', 'name': 'cds', 'fwd': False, 'opts': { 'color': (0.8, 0.8, 0.8), 'label': str(list_gene_state[3]), 'label_x_offset': -2, 'label_y_offset': -0.5, 'label_style': 'italic' } })) design.append(rec_matrix_attB_fwd[2]) design.append(Tf) design.append(Tr) if list_gene_state[0] != 0: design.append(({ 'type': 'CDS', 'name': 'cds', 'fwd': False, 'opts': { 'color': (0.8, 0.8, 0.8), 'label': str(list_gene_state[0]), 'label_x_offset': -2, 'label_y_offset': -0.5, 'label_style': 'italic' } })) design.append(rec_matrix_attB_fwd[0]) design.append(rec_matrix_attB_rev[1]) design.append(PR) design.append(rec_matrix_attP_rev[0]) if list_gene_state[1] != 0: design.append(({ 'type': 'CDS', 'name': 'cds', 'fwd': True, 'opts': { 'color': (0.8, 0.8, 0.8), 'label': str(list_gene_state[1]), 'label_x_offset': -2, 'label_y_offset': -0.5, 'label_style': 'italic' } })) design.append(Tf) design.append(Tr) if list_gene_state[2] != 0: design.append(({ 'type': 'CDS', 'name': 'cds', 'fwd': False, 'opts': { 'color': (0.8, 0.8, 0.8), 'label': str(list_gene_state[2]), 'label_x_offset': -2, 'label_y_offset': -0.5, 'label_style': 'italic' } })) design.append(rec_matrix_attP_fwd[2]) design.append(rec_matrix_attP_rev[1]) # construction for 4 inputs elif nb_input == 4: if list_gene_state[4] != 0: design.append(({ 'type': 'CDS', 'name': 'cds', 'fwd': False, 'opts': { 'color': (0.8, 0.8, 0.8), 'label': str(list_gene_state[4]), 'label_x_offset': -2, 'label_y_offset': -0.5, 'label_style': 'italic' } })) design.append(rec_matrix_attB_fwd[3]) design.append(rec_matrix_attB_fwd[0]) design.append(rec_matrix_attB_rev[1]) if list_gene_state[1] != 0: design.append(({ 'type': 'CDS', 'name': 'cds', 'fwd': True, 'opts': { 'color': (0.8, 0.8, 0.8), 'label': str(list_gene_state[1]), 'label_x_offset': -2, 'label_y_offset': -0.5, 'label_style': 'italic' } })) design.append(Tf) design.append(Tr) if list_gene_state[0] != 0: design.append(({ 'type': 'CDS', 'name': 'cds', 'fwd': False, 'opts': { 'color': (0.8, 0.8, 0.8), 'label': str(list_gene_state[0]), 'label_x_offset': -2, 'label_y_offset': -0.5, 'label_style': 'italic' } })) design.append(rec_matrix_attP_rev[0]) design.append(rec_matrix_attB_rev[2]) design.append(PR) design.append(rec_matrix_attP_rev[1]) if list_gene_state[2] != 0: design.append(({ 'type': 'CDS', 'name': 'cds', 'fwd': True, 'opts': { 'color': (0.8, 0.8, 0.8), 'label': str(list_gene_state[2]), 'label_x_offset': -2, 'label_y_offset': -0.5, 'label_style': 'italic' } })) design.append(Tf) design.append(Tr) if list_gene_state[3] != 0: design.append(({ 'type': 'CDS', 'name': 'cds', 'fwd': False, 'opts': { 'color': (0.8, 0.8, 0.8), 'label': str(list_gene_state[3]), 'label_x_offset': -2, 'label_y_offset': -0.5, 'label_style': 'italic' } })) design.append(rec_matrix_attP_fwd[3]) design.append(rec_matrix_attP_rev[2]) # construction for 5 inputs elif nb_input == 5: if list_gene_state[5] != 0: design.append(({ 'type': 'CDS', 'name': 'cds', 'fwd': False, 'opts': { 'color': (0.8, 0.8, 0.8), 'label': str(list_gene_state[5]), 'label_x_offset': -2, 'label_y_offset': -0.5, 'label_style': 'italic' } })) design.append(rec_matrix_attB_fwd[4]) design.append(rec_matrix_attB_fwd[1]) design.append(rec_matrix_attB_rev[2]) if list_gene_state[2] != 0: design.append(({ 'type': 'CDS', 'name': 'cds', 'fwd': True, 'opts': { 'color': (0.8, 0.8, 0.8), 'label': str(list_gene_state[2]), 'label_x_offset': -2, 'label_y_offset': -0.5, 'label_style': 'italic' } })) design.append(Tf) design.append(Tr) if list_gene_state[1] != 0: design.append(({ 'type': 'CDS', 'name': 'cds', 'fwd': False, 'opts': { 'color': (0.8, 0.8, 0.8), 'label': str(list_gene_state[1]), 'label_x_offset': -2, 'label_y_offset': -0.5, 'label_style': 'italic' } })) design.append(rec_matrix_attB_fwd[0]) design.append(rec_matrix_attP_fwd[1]) design.append(Tr) design.append(rec_matrix_attP_rev[0]) design.append(rec_matrix_attB_rev[3]) design.append(PR) design.append(rec_matrix_attP_rev[2]) if list_gene_state[3] != 0: design.append(({ 'type': 'CDS', 'name': 'cds', 'fwd': True, 'opts': { 'color': (0.8, 0.8, 0.8), 'label': str(list_gene_state[3]), 'label_x_offset': -2, 'label_y_offset': -0.5, 'label_style': 'italic' } })) design.append(Tf) design.append(Tr) if list_gene_state[4] != 0: design.append(({ 'type': 'CDS', 'name': 'cds', 'fwd': False, 'opts': { 'color': (0.8, 0.8, 0.8), 'label': str(list_gene_state[4]), 'label_x_offset': -2, 'label_y_offset': -0.5, 'label_style': 'italic' } })) design.append(rec_matrix_attP_fwd[4]) design.append(rec_matrix_attP_rev[3]) ## Design Integrase cassettes design_int = [] i = 0 sp = { 'type': 'EmptySpace', 'name': 's', 'fwd': True, 'opts': { 'x_extent': 1 } } name_input = 'abcdefghijklmnopqrstuvwxyz' for integrase in range(1, nb_input + 1): if integrase != '0': i += 1 design_int.append({ 'type': 'Promoter', 'name': 'prom', 'fwd': True, 'opts': { 'label': 'P' + str(name_input[i - 1]), 'label_x_offset': -2, 'label_y_offset': -6 } }) int_gene = { 'type': 'CDS', 'name': 'cds', 'fwd': True, 'opts': { 'color': col_map_matrix[integrase - 1], 'label_x_offset': -2, 'label_y_offset': -0.5, 'label': 'int' + str(integrase), 'label_style': 'italic' } } design_int.append(int_gene) design_int.append({ 'type': 'Terminator', 'name': 'term', 'fwd': True, 'opts': { 'color': (0.5, 0.5, 0.5) } }) design_int.append(sp) design_int.append(sp) design_int.append(sp) design_int.append(sp) # Create the figure fig = plt.figure(figsize=(3, 1)) gs = gridspec.GridSpec(2, 1) ax_dna1 = plt.subplot(gs[1]) ax_dna2 = plt.subplot(gs[0]) # Redender the DNA to axis start, end = dr.renderDNA(ax_dna1, design, part_renderers) ax_dna1.set_xlim([start, end]) ax_dna1.set_ylim([-17, 17]) ax_dna1.set_aspect('equal') ax_dna1.set_xticks([]) ax_dna1.set_yticks([]) ax_dna1.axis('off') start, end = dr.renderDNA(ax_dna2, design_int, part_renderers) ax_dna2.set_xlim([start, end]) ax_dna2.set_ylim([-13, 13]) ax_dna2.set_aspect('equal') ax_dna2.set_xticks([]) ax_dna2.set_yticks([]) ax_dna2.axis('off') # Update subplot spacing #plt.subplots_adjust(hspace=0.01, left=0.05, right=0.95, top=0.92, bottom=0.01) #plt.title(title, fontsize=7) # Save the figure fig.savefig(name_directory + '/' + dirc_number + '_' + title + '.png', dpi=300) # Clear the plotting cache plt.close('all')
def computation_device(inp, strain, int_list, title, name_directory, directory_number): # Create the DNAplotlib renderer dr = dpl.DNARenderer() # Use default renderers and append our custom ones for recombinases reg_renderers = dr.std_reg_renderers() reg_renderers['Connection'] = rec.flip_arrow part_renderers = dr.SBOL_part_renderers() part_renderers['RecombinaseSite'] = rec.sbol_recombinase1 part_renderers['RecombinaseSite2'] = rec.sbol_recombinase2 # Create the construct programmably to plot PF = {'type': 'Promoter', 'name': 'prom', 'fwd': True} out_off = { 'type': 'CDS', 'name': 'cds', 'fwd': True, 'opts': { 'color': (0.8, 0.8, 0.8), 'label_x_offset': -2, 'label_y_offset': -0.5, 'label_style': 'italic', 'label': 'GOI' } } term = {'type': 'Terminator', 'name': 'term', 'fwd': True} sp = { 'type': 'EmptySpace', 'name': 's', 'fwd': True, 'opts': { 'x_extent': 1 } } ##initalization of list # list of attB sites rec_matrix_attB = [] # list of attP sites rec_matrix_attP = [] # list with the full design design = [] #number of input in this module nb_input = int(inp[0]) # for all nb_input add the corresponding attB and attP site in fwd direction to the corresponding list for X in range(0, nb_input): siteB = ({ 'type': 'RecombinaseSite', 'name': 'Site1', 'fwd': True, 'opts': { 'color': col_map_matrix[X], 'x_extent': 16, 'y_extent': 12, 'start_pad': 3, 'end_pad': 3 } }) rec_matrix_attB.append(siteB) siteP = ({ 'type': 'RecombinaseSite', 'name': 'Site1', 'fwd': True, 'opts': { 'color': col_map_matrix[X], 'x_extent': 16, 'y_extent': 12, 'start_pad': 3, 'end_pad': 3 } }) rec_matrix_attP.append(siteP) # number of ZERO correspond to number of total variables (0) - number of ONE (1) ZERO = int(inp[0]) - int(inp[1]) # variables that correspond to ZERO, in reverse order for Z in reversed(range(0, ZERO)): # append to the design the attB site design.append(rec_matrix_attB[Z]) # append to the design the promoter in fwd direction design.append(PF) # variable which correspond to ZERO for Z in range(0, ZERO): # append attP site design.append(rec_matrix_attP[Z]) # variable which correspond to ONE for O in range(ZERO, int(inp[0])): # add attB site+term+attP site design.append(rec_matrix_attB[O]) design.append(term) design.append(rec_matrix_attP[O]) # append output gene design.append(out_off) ##DESIGN OF INTEGRASE CASSETTE design_int = [] i = 0 name_input = 'abcdefghijklmnopqrstuvwxyz' #name_input='ABCDEFGHIJKLMNOPQRSTUVWXYZ' for integrase in int_list: i += 1 if integrase != '0': design_int.append({ 'type': 'Promoter', 'name': 'prom', 'fwd': True, 'opts': { 'label': 'P' + str(name_input[i - 1]), 'label_x_offset': -2, 'label_y_offset': -6 } }) int_gene = { 'type': 'CDS', 'name': 'cds', 'fwd': True, 'opts': { 'color': col_map_matrix[int(integrase) - 1], 'label_x_offset': -2, 'label_y_offset': -0.5, 'label': 'int' + str(integrase), 'label_style': 'italic' } } design_int.append(int_gene) design_int.append({ 'type': 'Terminator', 'name': 'term', 'fwd': True, 'opts': { 'color': (0.5, 0.5, 0.5) } }) design_int.append(sp) design_int.append(sp) design_int.append(sp) design_int.append(sp) # Create the figure fig = plt.figure(figsize=(3, 1)) gs = gridspec.GridSpec(2, 1) ax_dna1 = plt.subplot(gs[1]) ax_dna2 = plt.subplot(gs[0]) # Redender the DNA to axis start, end = dr.renderDNA(ax_dna1, design, part_renderers) ax_dna1.set_xlim([start, end]) ax_dna1.set_ylim([-18, 18]) ax_dna1.set_aspect('equal') ax_dna1.set_xticks([]) ax_dna1.set_yticks([]) ax_dna1.axis('off') start, end = dr.renderDNA(ax_dna2, design_int, part_renderers) ax_dna2.set_xlim([start, end]) ax_dna2.set_ylim([-18, 18]) ax_dna2.set_aspect('equal') ax_dna2.set_xticks([]) ax_dna2.set_yticks([]) ax_dna2.axis('off') # Update subplot spacing plt.subplots_adjust(hspace=0.01, left=0.05, right=0.95, top=0.92, bottom=0.01) #hfont={'fontname':'Helevetica Neue'} #plt.title('For strain '+strain+', the computation device is:', fontsize=4) #plt.suptitle(subtitle, x = 0.5, y= 0.3, fontsize=5, **hfont) # Save the figure fig.savefig(name_directory + '/' + directory_number + '_' + title + '.png', dpi=300) # Clear the plotting cache plt.close('all')
def plot_dna(dna_designs, out_filename, plot_params, regs_info): # Create the renderer if 'axis_y' not in plot_params.keys(): plot_params['axis_y'] = 35 left_pad = 0.0 right_pad = 0.0 scale = 1.0 linewidth = 1.0 fig_y = 5.0 fig_x = 5.0 if 'backbone_pad_left' in plot_params.keys(): left_pad = plot_params['backbone_pad_left'] if 'backbone_pad_right' in plot_params.keys(): right_pad = plot_params['backbone_pad_right'] if 'scale' in plot_params.keys(): scale = plot_params['scale'] if 'linewidth' in plot_params.keys(): linewidth = plot_params['linewidth'] if 'fig_y' in plot_params.keys(): fig_y = plot_params['fig_y'] if 'fig_x' in plot_params.keys(): fig_x = plot_params['fig_x'] dr = dpl.DNARenderer(scale=scale, linewidth=linewidth, backbone_pad_left=left_pad, backbone_pad_right=right_pad) # We default to the standard regulation renderers reg_renderers = dr.std_reg_renderers() # We default to the SBOL part renderers part_renderers = dr.SBOL_part_renderers() # Create the figure fig = plt.figure(figsize=(fig_x, fig_y)) # Cycle through the designs an plot on individual axes design_list = sorted(dna_designs.keys()) if (regs_info != None): regs_list = sorted(regs_info.keys()) num_of_designs = len(design_list) ax_list = [] max_dna_len = 0.0 for i in range(num_of_designs): # Create axis for the design and plot regs = None if (regs_info != None): regs = regs_info[i] design = dna_designs[design_list[i]] ax = fig.add_subplot(num_of_designs, 1, i + 1) if 'show_title' in plot_params.keys( ) and plot_params['show_title'] == 'Y': ax.set_title(design_list[i], fontsize=8) start, end = dr.renderDNA(ax, design, part_renderers, regs, reg_renderers) dna_len = end - start if max_dna_len < dna_len: max_dna_len = dna_len ax_list.append(ax) for ax in ax_list: ax.set_xticks([]) ax.set_yticks([]) # Set bounds ax.set_xlim([(-0.01 * max_dna_len) - left_pad, max_dna_len + (0.01 * max_dna_len) + right_pad]) ax.set_ylim([-plot_params['axis_y'], plot_params['axis_y']]) ax.set_aspect('equal') ax.set_axis_off() # Update the size of the figure to fit the constructs drawn fig_x_dim = max_dna_len / 70.0 if fig_x_dim < 1.0: fig_x_dim = 1.0 fig_y_dim = 1.2 * len(ax_list) plt.gcf().set_size_inches((fig_x_dim, fig_y_dim)) # Save the figure plt.tight_layout() fig.savefig(out_filename, transparent=True, dpi=300) # Clear the plotting cache plt.close('all')
def create_sbol(construct, name): # get the circuit string and transform it into an iterable list # structure: <part 1 type>:<part 1 name>,<part 2 type>:<part 2 name> plasmids = construct.split('//') # // separates different plasmids for idx in range(len(plasmids)): plasmids[idx] = plasmids[idx].split( ',') # , separates different parts in the same plasmid designs = [] sp = { 'type': 'EmptySpace', 'name': 'S1', 'fwd': True } # dnaplotlib tag for empty spaces max_length = len(max( plasmids, key=len)) # get the length (in parts) of the biggest plasmid # set font size and line width based on how much the image will be shrinked font_size = 20 / max([len(plasmids), max_length / 4]) line_size = 2 / len(plasmids) d = 0 for plasmid in plasmids: designs.append([]) for part in plasmid: #set offset for parts names if plasmid.index(part) % 2 == 0: y_offset = 20 else: y_offset = -15 part = part.replace(' ', '') # handle spaces in circuit string designs[d].append(sp) designs[d].append({ 'type': part.split(':')[0], 'name': part.split(':')[1], 'fwd': True, 'opts': { 'label': part.split(':')[1], 'label_size': font_size, 'label_y_offset': y_offset } }) d += 1 dr = dpl.DNARenderer(linewidth=line_size) # dnaplotlib renderer object if len( designs ) > 1: # making subplots only makes sense if there are multiple plasmids fig, axs = plt.subplots(len(designs)) for idx in range( len(designs) ): # use dnapltlib's standard drawing commands (got from their github) start, end = dr.renderDNA(axs[idx], designs[idx], dr.SBOL_part_renderers()) axs[idx].set_xlim([start, end]) axs[idx].set_ylim([-25, 25]) axs[idx].set_aspect('equal') axs[idx].set_xticks([]) axs[idx].set_yticks([]) axs[idx].axis('off') fig.set_figwidth(0.75 * max_length) else: fig = plt.figure() ax = plt.axes() start, end = dr.renderDNA(ax, designs[0], dr.SBOL_part_renderers()) ax.set_xlim([start, end]) ax.set_ylim([-25, 25]) ax.set_aspect('equal') ax.set_xticks([]) ax.set_yticks([]) ax.axis('off') # save figure with appropriate name and close everything fig.savefig('../database/images/part_' + name + '.png') plt.close('all')
def plot_mean_sigma_genes_v2(INI_file, sigma_info, RNAPs_pos_info): # path to the input files (remove the "params.ini" from the path) path = INI_file.rpartition("/")[0] + "/" if path=="/": path="./" # read the config file config = sim.read_config_file(INI_file) # get inputs infos from the config file GFF_file = path+config.get('INPUTS', 'GFF') TSS_file = path+config.get('INPUTS', 'TSS') TTS_file = path+config.get('INPUTS', 'TTS') Prot_file = path+config.get('INPUTS', 'BARR_FIX') SIGMA_0 = config.getfloat('SIMULATION', 'SIGMA_0') DELTA_X = config.getfloat('SIMULATION', 'DELTA_X') # load and get BARR_FIX positions prot = sim.load_tab_file(Prot_file) BARR_FIX = (prot['prot_pos'].values).astype(int) # To draw the beautiful genes we need to read the GFF, TSS and TTS files to get some info ;) gff_df_raw = sim.load_gff(GFF_file) # to get the cov_bp (a verifier) genome_size = sim.get_genome_size(gff_df_raw) genome = int(genome_size/DELTA_X) cov_bp = np.arange(0, genome_size, DELTA_X) cov_bp = np.resize(cov_bp, genome) gff_df = sim.rename_gff_cols(gff_df_raw) tss = sim.load_tab_file(TSS_file) Kon = tss['TSS_strength'].values tts = sim.load_tab_file(TTS_file) Poff = tts['TTS_proba_off'].values strands = sim.str2num(gff_df['strand'].values) # Create the figure and all axes to draw to fig = plt.figure(1, figsize=(9,6)) # 3.2,2.7 gs = gridspec.GridSpec(2, 1, height_ratios=[9, 3, 1]) # Color maps for formatting col_map = {} col_map['red'] = (0.95, 0.30, 0.25) col_map['green'] = (0.38, 0.82, 0.32) col_map['blue'] = (0.38, 0.65, 0.87) col_map['orange'] = (1.00, 0.75, 0.17) col_map['purple'] = (0.55, 0.35, 0.64) col_map['yellow'] = (0.98, 0.97, 0.35) col_map['grey'] = (0.70, 0.70, 0.70) col_map['dark_grey'] = (0.60, 0.60, 0.60) col_map['light_grey'] = (0.9, 0.9, 0.9) # CDS formatting options opt_CDSs = [] Ps = [] CDSs = [] Ts = [] design = [] for i in gff_df.index.values: opt_CDSs.append({'label':'Gene%s \n%.03f'%(str(i+1),Kon[i]), 'label_style':'italic', 'label_y_offset':-5, 'color':col_map['orange']}) # Design of the construct if strands[i] == True: # Promoters Ps.append({'type':'Promoter', 'name':'P%s'%str(i+1), 'start':tss['TSS_pos'][i], 'end':tss['TSS_pos'][i]+5, 'fwd':strands[i], 'opts':{'color':col_map['green']}}) # Coding Sequence CDSs.append({'type':'CDS', 'name':'CDS%s'%str(i+1), 'start':gff_df['start'][i], 'end':gff_df['end'][i], 'fwd':gff_df['strand'][i], 'opts':opt_CDSs[i]}) else: # Promoters Ps.append({'type':'Promoter', 'name':'P%s'%str(i+1), 'start':tss['TSS_pos'][i], 'end':tss['TSS_pos'][i]-5, 'fwd':strands[i], 'opts':{'color':col_map['green']}}) # Coding Sequence CDSs.append({'type':'CDS', 'name':'CDS%s'%str(i+1), 'start':gff_df['end'][i], 'end':gff_df['start'][i], 'fwd':gff_df['strand'][i], 'opts':opt_CDSs[i]}) # Terminators Ts.append({'type':'Terminator', 'name':'T%s'%str(i+1), 'start':tts['TTS_pos'][i], 'end':tts['TTS_pos'][i]+5, 'fwd':strands[i], 'opts':{'color':col_map['red']}}) # A design is merely a list of parts and their properties if strands[i] == True: design.append(Ps[i]) design.append(CDSs[i]) design.append(Ts[i]) else: design.append(Ts[i]) design.append(CDSs[i]) design.append(Ps[i]) ax_mean_sig = plt.subplot(gs[0]) ax_dna = plt.subplot(gs[1]) # Redender the DNA dr = dpl.DNARenderer(scale=7, linewidth=1) start, end = dr.renderDNA(ax_dna, design, dr.trace_part_renderers()) # Set bounds and display options for the DNA axis dna_len = end-start ax_dna.set_xlim([cov_bp[0], cov_bp[-1]]) #start-50 ax_dna.set_ylim([-8,8]) #ax_dna.plot(5000, 'ro', markersize=15) for xc in BARR_FIX: ax_dna.axvline(x=xc, ymin=0.40, ymax=0.60, color='k', linewidth=5) ax_dna.plot([cov_bp[0],cov_bp[-1]], [0,0], color=(0,0,0), linewidth=1.0, zorder=1) ax_dna.axis('off') # plot of sigma and mean of sigma plt.ion() ax_mean_sig.plot(cov_bp, sigma_info, linewidth= 1.5) ax_mean_sig.legend(loc='best', fontsize = 12) ax_mean_sig.set_ylim([-0.2,0.2]) ax_mean_sig.set_xlim([0, cov_bp[-1]]) #ax_mean_sig.set_title(r"Title goes here", fontsize = 13) ax_mean_sig.set_ylabel(r'Supercoiling density $(\sigma)$') ax_mean_sig.set_xlabel('Position (bp)') ax_mean_sig.plot(RNAPs_pos_info*DELTA_X, np.full(len(RNAPs_pos_info), SIGMA_0, dtype=float), 'ro', markersize=12, label = "RNA Polymerase") ax_mean_sig.set_ylim([-0.2, 0.2]) plt.pause(0.001) plt.gcf().clear() plt.show()
def plot_circuit(self, Input, Regulation=None, savefig=None): """Plot the SBOL-compliant gene circuit figure. :param Input: Input design from users :type Input: str :param Regulation: Regulation strings from users :type Regulation: str :param savefig: path to store the output figure :type savefig: str, optional :return: max dna design length and export the gene circuit figure :rtype: float """ # matplotlib.use("Qt5Agg") matplotlib.use("Agg") dr = dpl.DNARenderer(linewidth=1.5) # Process the arguments design, Regulations = self.set_circuit_design(Input, Regulation) reg_renderers = dr.std_reg_renderers() part_renderers = dr.SBOL_part_renderers() # Generate the figure fig = plt.figure(figsize=(1.0, 1.0), dpi=100) ax = fig.add_subplot(1, 1, 1) # Plot the design dna_start, dna_end = dr.renderDNA(ax, design, part_renderers, Regulations, reg_renderers) max_dna_len = dna_end - dna_start # print("Max Dna length: ", max_dna_len) # Format the axis ax.set_xticks([]) ax.set_yticks([]) # Set bounds ax.set_xlim([(-0.0 * max_dna_len), max_dna_len + (0.0 * max_dna_len)]) ax.set_ylim([-25, 25]) ax.set_aspect("equal") ax.set_axis_off() # Update the size of the figure to fit the constructs drawn fig_x_dim = max_dna_len / 30 # print("x_dim: ", fig_x_dim) if fig_x_dim < 1.0: fig_x_dim = 1.0 fig_y_dim = 1.8 plt.gcf().set_size_inches(fig_x_dim, fig_y_dim, forward=True) # Save the figure plt.tight_layout() if savefig is not None: fig.savefig(savefig, transparent=True, dpi=300) # plt.show() return max_dna_len, fig
def legend(nb_input, name_directory, directory_number): # Create the DNAplotlib renderer dr = dpl.DNARenderer() # Use default renderers and append our custom ones for recombinases reg_renderers = dr.std_reg_renderers() reg_renderers['Connection'] = rec.flip_arrow part_renderers = dr.SBOL_part_renderers() part_renderers['RecombinaseSite'] = rec.sbol_recombinase1 part_renderers['RecombinaseSite2'] = rec.sbol_recombinase2 # list with the full design design = [] subtitle = '' # for all nb_input add the corresponding attB and attP site in fwd direction to the corresponding list for X in range(0, nb_input): siteB = ({ 'type': 'RecombinaseSite', 'name': 'Site1', 'fwd': True, 'opts': { 'color': col_map_matrix[X], 'x_extent': 16, 'y_extent': 12, 'start_pad': 3, 'end_pad': 3 } }) design.append(siteB) subtitle += 'int' + str(X + 1) + ' ' # Create the figure fig = plt.figure(figsize=(3, 1)) gs = gridspec.GridSpec(2, 1) ax_dna1 = plt.subplot(gs[0]) # Redender the DNA to axis start, end = dr.renderDNA(ax_dna1, design, part_renderers) #start, end = dr.renderDNA(design) ax_dna1.set_xlim([start, end]) ax_dna1.set_ylim([-18, 18]) ax_dna1.set_aspect('equal') ax_dna1.set_xticks([]) ax_dna1.set_yticks([]) ax_dna1.axis('off') # Update subplot spacing plt.subplots_adjust(hspace=0.01, left=0.05, right=0.95, top=0.92, bottom=0.01) #plt.title('legend', fontsize=7) plt.suptitle(subtitle, x=0.5, y=0.9, fontsize=5) # Save the figure fig.savefig(name_directory + '/' + directory_number + '_legend.png', dpi=300) # Clear the plotting cache plt.close('all')
def plot_dna(dna_designs, dna_design_order, out_filename, plot_params, perf_data): # Default parameters for the plotting if 'axis_y' not in plot_params.keys(): plot_params['axis_y'] = 35 left_pad = 0.0 right_pad = 0.0 scale = 1.0 linewidth = 1.0 fig_y = 5.0 fig_x = 5.0 # Update parameters if needed if 'backbone_pad_left' in plot_params.keys(): left_pad = plot_params['backbone_pad_left'] if 'backbone_pad_right' in plot_params.keys(): right_pad = plot_params['backbone_pad_right'] if 'scale' in plot_params.keys(): scale = plot_params['scale'] if 'linewidth' in plot_params.keys(): linewidth = plot_params['linewidth'] if 'fig_y' in plot_params.keys(): fig_y = plot_params['fig_y'] if 'fig_x' in plot_params.keys(): fig_x = plot_params['fig_x'] dr = dpl.DNARenderer(scale=scale, linewidth=linewidth, backbone_pad_left=left_pad, backbone_pad_right=right_pad) # We default to the SBOL part renderers part_renderers = dr.SBOL_part_renderers() # Create the figure fig = plt.figure(figsize=(3.6, 6.2)) # Cycle through the designs an plot on individual axes design_list = sorted(dna_designs.keys()) num_of_designs = len(design_list) ax_list = [] max_dna_len = 0.0 gs = gridspec.GridSpec(num_of_designs, 2, width_ratios=[1, 12]) # Plot the genetic designs for i in range(len(dna_design_order)): # Create axis for the design and plot design = dna_designs[dna_design_order[i]] ax = plt.subplot(gs[i, 1]) if 'show_title' in plot_params.keys( ) and plot_params['show_title'] == 'Y': ax.set_title(design_list[i], fontsize=8) start, end = dr.renderDNA(ax, design, part_renderers) dna_len = end - start if max_dna_len < dna_len: max_dna_len = dna_len ax_list.append(ax) for ax in ax_list: ax.set_xticks([]) ax.set_yticks([]) # Set bounds ax.set_xlim([(-0.01 * max_dna_len) - left_pad, max_dna_len + (0.01 * max_dna_len) + right_pad]) ax.set_ylim([-14, 14]) ax.set_aspect('equal') ax.set_axis_off() # Plot the performance data (bar charts) perf_vals = extract_dict_attribs(perf_data, dna_design_order, 'Activity') perf_sd_vals = extract_dict_attribs(perf_data, dna_design_order, 'Activity_SD') ax_perf = plt.subplot(gs[:, 0]) bar_height = 0.3 ax_perf.plot([1], [1]) ax_perf.spines['top'].set_visible(False) ax_perf.spines['bottom'].set_visible(False) ax_perf.spines['right'].set_visible(False) ax_perf.invert_yaxis() ax_perf.set_xticks([]) ax_perf.yaxis.tick_left() ax_perf.yaxis.set_ticks_position('left') ax_perf.tick_params(axis='y', direction='out') ax_perf.tick_params('y', length=3, width=0.8, which='major', pad=2, labelsize=8) pos1 = np.arange(len(perf_vals)) ax_perf.barh(pos1, perf_vals, height=bar_height, color=(0.6, 0.6, 0.6), edgecolor=(0.6, 0.6, 0.6)) ax_perf.errorbar(perf_vals, pos1 + (bar_height / 2.0), fmt='none', xerr=perf_sd_vals, ecolor=(0, 0, 0), capthick=1) ax_perf.set_yticks(pos1 + (bar_height / 2.0)) ax_perf.set_yticklabels(dna_design_order) ax_perf.set_ylim([max(pos1) + 0.65, -0.35]) ax_perf.set_xlim([0, 1062606 * 1.05]) # Save the figure plt.subplots_adjust(hspace=0.001, wspace=0.05, top=0.99, bottom=0.01, left=0.06, right=0.99) fig.savefig(out_filename, transparent=True, dpi=300) # Clear the plotting cache plt.close('all')
# Create the figure fig = plt.figure(figsize=(3.0, 1.5)) gs = gridspec.GridSpec(1, 1) ax_dna = plt.subplot(gs[0]) # This is the main sequence seq1 = 'AATTCCGAGCGCGAGCTTTGCGAGTGA' draw_sequence(ax_dna, 0, 0, seq1) # Another sequence to show you can overlay them if needed with an offset seq2 = 'TTGCGAGTGA' draw_sequence(ax_dna, 8, 5, seq2) # Create the DNAplotlib renderer and map of part types to renderering functions dr = dpl.DNARenderer() part_renderers = {'PromoterRegion': promoter_region} # Create the sites to draw r1 = { 'type': 'PromoterRegion', 'name': 'region1', 'start': 2, 'end': 13, 'fwd': True, 'opts': { 'y_offset': 10, 'len_35': 1, 'len_10': 1, 'color_35': (0, 0.5, 0.2), 'color_10': (0.9, 0.2, 0.7)
import numpy as np __author__ = 'Thomas Gorochowski <*****@*****.**>, Voigt Lab, MIT' __license__ = 'MIT' __version__ = '1.0' # Load the design from a GFF file cur_region = [1700, 15880] design = dpl.load_design_from_gff('plasmid.gff', 'chrom1', region=cur_region) profile_fwd = dpl.load_profile_from_bed('plasmid_fwd_profile.txt', 'chrom1', [0, 22953]) profile_rev = dpl.load_profile_from_bed('plasmid_rev_profile.txt', 'chrom1', [0, 22953]) # Create the DNAplotlib renderer dr = dpl.DNARenderer(scale=10.0) part_renderers = dr.trace_part_renderers() # Create the figure fig = plt.figure(figsize=(3.5, 2.0)) gs = gridspec.GridSpec(2, 1, height_ratios=[1, 0.2]) ax_dna = plt.subplot(gs[1]) # Redender the DNA to axis start, end = dr.renderDNA(ax_dna, design, part_renderers) ax_dna.set_xlim(cur_region) ax_dna.set_ylim([-5, 8]) ax_dna.axis('off') ax_profile = plt.subplot(gs[0]) ax_profile.fill_between(list(range(cur_region[0], cur_region[1])),