def sculpt(self,cleanup=0): if not cleanup: cmd.set("suspend_updates",1,quiet=1) cmd.disable() cmd.delete("sculpt") cmd.set("sphere_scale","1.0") cmd.set("sphere_mode",5) cmd.load("$PYMOL_DATA/demo/pept.pdb","sculpt") cmd.hide("lines","sculpt") # cmd.show("sticks","sculpt") cmd.show("spheres","sculpt") # cmd.set("sphere_transparency","0.75","sculpt") # cmd.set("sphere_color","grey","sculpt") cmd.frame(1) cmd.set("auto_sculpt",1) cmd.set("sculpting",1) cmd.sculpt_activate("sculpt") cmd.set("sculpting_cycles","100") cmd.do("edit_mode") cmd.set("valence","0.05") cmd.set("suspend_updates",0,quiet=0) cmd.sculpt_iterate("sculpt") cmd.alter_state(1,"sculpt","x=x*1.5;y=y*0.1;z=z*1.5") cmd.zoom() cmd.unpick() else: cmd.set("valence","0") cmd.set("sculpting",0) cmd.set("auto_sculpt",0) cmd.delete("sculpt") cmd.mouse()
def de(pdbfile1="IL1B.atm", pdbfile2="MIM_tor.atm", charges=True, logscale=True, dielectric=80., eps=0.1): # extract names, and create the 'object' name in the pymol menu window #pdbobj1 = pdbfile1[:-4] pdbobj1 = 'dockeye_prt' cmd.load(pdbfile1, pdbobj1) #pdbobj2 = pdbfile2[:-4] #cmd.load(pdbfile2, pdbobj2) # # Dockeye class reads pdb file upon init pdbobj2 = 'dockeye_lig' obj = Dockeye(pdbfile1, pdbfile2, pdbobj1, pdbobj2, charges, logscale, dielectric, eps) # # but pymol also loads first ligand model for display cmd.load('dockeye_lig.pdb', pdbobj2) os.system('rm -f dockeye_lig.pdb') cmd.zoom() cmd.do("set auto_zoom, off", echo=0) name = 'dockeye' cmd.load_callback(obj, name) return obj
def testMeasureBetweenStates(self): cmd.load(self.datafile('1v5a-3models.cif'), 'm1') # distance d = cmd.distance('d1', '24/CZ', 'same', state1=2, state2=3) self.assertAlmostEqual(d, 3.0, delta=1e-1) # angle a = cmd.angle('a1', '24/CZ', 'same', 'same', state1=2, state2=3, state3=1) self.assertAlmostEqual(a, 73.5, delta=1e-1) # visual test cmd.viewport(100, 100) cmd.set('dash_radius', 1.0) self.ambientOnly() for name in ['d1', 'a1']: cmd.disable('*') cmd.enable(name) cmd.zoom(name) self.assertImageHasColor('yellow')
def rotate_and_capture(self, rotation_axis, increment, res_width, res_height): self.images_for_gif = [] self.images_for_mp4 = [] # cycles through all possible angles (multiple of increment) for current_angle in range(0, 360, increment): cmd.rotate(rotation_axis, angle=increment) # creates the file folder if it doesn't exist if not os.path.exists(str(self.file_path)): os.makedirs(str(self.file_path)) # file_name = str(self.file_path/"{}_{}.png".format(self.protein, str(current_angle))) file_name = str(self.file_path / f"{self.method.name}_{str(current_angle)}.png") cmd.zoom(complete=1) cmd.png(file_name, width=res_width, height=res_height, dpi=500, ray=1, quiet=0) self.drawLegend(file_name, res_width, res_height) self.images_for_gif.append(imageio.imread(file_name)) self.images_for_mp4.append(cv2.imread(file_name))
def load(): cmd.set("valence") r = 0 list = glob("pdb/*/*") # while list[0]!="pdb/f8/pdb1f8u": # list.pop(0) for file in list: try: cmd.delete('pdb') cmd.load(file,'pdb') cmd.set_title('pdb',1,os.path.split(file)[-1]) cmd.rewind() cmd.orient('pdb') cmd.refresh() cmd.zoom('center',16) cmd.label("polymer and (name ca or elem P)","'//%s/%s/%s`%s/%s'%(segi,chain,resn,resi,name)") cmd.refresh() sys.__stderr__.write(".") sys.__stderr__.flush() n = cmd.count_states() if n>1: cmd.rewind() sys.__stderr__.write(file+"\n") sys.__stderr__.flush() for a in range(1,n+1): cmd.forward() cmd.refresh() except: traceback.print_exc()
def zoom_tetramer_1a8y(object_name): # Get a neutral, symmetric view of the molecule(s) # cmd.viewport(viewport_width_tetramer(), viewport_height_tetramer()) cmd.orient(object_name) cmd.rotate("y", 180) cmd.zoom("center", 45) return
def testLabelPositionZ(self, use_shaders, ray): ''' Test label z position for regular labels ''' if not ray and invocation.options.no_gui: self.skipTest('no gui') cmd.set('use_shaders', use_shaders) cmd.viewport(200, 200) cmd.pseudoatom('m1', vdw=10, label='X') cmd.zoom(buffer=12) cmd.show('spheres') cmd.color('blue') cmd.set('label_color', 'red') cmd.set('label_size', 20) cmd.set('label_font_id', 7) # bold self.ambientOnly() # label outside of sphere cmd.set('label_position', [0, 0, 11.1]) img = self.get_imagearray(ray=ray) self.assertImageHasColor('blue', img) self.assertImageHasColor('red', img, delta=20) # label inside of sphere cmd.set('label_position', [0, 0, 10.5]) img = self.get_imagearray(ray=ray) self.assertImageHasColor('blue', img) self.assertImageHasNotColor('red', img, delta=20)
def plot(self, outfile): ctrl_id, case_id, snp_df_sub = self.score_on_var() df = pd.merge(snp_df_sub, self.snps2aa, on='id') #pymol.finish_launching() cmd.reinitialize() cmd.fetch(self.pdb) cmd.alter(self.pdb, 'b = 0.5') cmd.show_as('cartoon', self.pdb) cmd.color('white', self.pdb) for i, row in df.iterrows(): resi = row['structure_position'] chain = row['chain'] pheno = row['es'] selec = 'snp%s' % i selec_atom = 'snp_atom%s' % i cmd.select(selec, 'name ca and resi %s and chain %s' % (resi, chain)) cmd.create(selec_atom, selec) cmd.set("sphere_scale", 0.8) cmd.show('sphere', selec_atom) cmd.alter(selec_atom, 'b=%s' % pheno) cmd.spectrum("b", "blue_white_red", selec_atom, maximum=1.0, minimum=0.0) cmd.bg_color("white") cmd.zoom() cmd.orient() cmd.save('%s.pse' % outfile) cmd.png('%s.png' % outfile, width=2400, height=2400, dpi=300, ray=1)
def iter(self, by=1): loaded = cmd.get_names('objects')[0] choices = self.choices() l = len(choices) next_file = 0 next_file_index = 0 for i in range(l): if objname(choices[i]) == loaded: next_file_index = (i + by) % l next_file = choices[(i + by) % l] break cmd.delete('all') if not os.path.exists(next_file): raise ValueError("Can not locate file: %s" % next) cmd.load(next_file) if self.auto_zoom: cmd.zoom() if self.onload_command: logging.debug("onload_command: %s", self.onload_command) cmd.do(self.onload_command) #cmd.replace_wizard('message',next_file) # to display current pdb index, start at 1 cmd.replace_wizard( 'message', next_file + ", %d/%d" % (next_file_index + 1, l)) # +1, so the cycler starts at 1
def testLabelRelativeMode(self): # +-----+-----+ # | | | # +-----+-----+ # | XYZ | | # +-----+-----| self.ambientOnly() cmd.set('opaque_background') cmd.set('label_font_id', 7) # bold cmd.set('label_color', 'white') cmd.set('label_size', -1) # Angstrom sized cmd.pseudoatom('m1', label="XYZ") cmd.zoom() width = 400 height = 200 w4 = width // 4 h4 = height // 4 cmd.viewport(width, height) for x in (-1, 1): for y in (-1, 1): # relative position cmd.set('label_relative_mode', 1) cmd.set('label_screen_point', (0.5 * x, 0.5 * y, 0)) self.assertColorInQuadrant(x, y, width, height) # absolute position in pixels cmd.set('label_relative_mode', 2) cmd.set('label_screen_point', ((2 + x) * w4, (2 + y) * h4, 0)) self.assertColorInQuadrant(x, y, width, height)
def align_all( subset = [] ): """ Superimpose all open models onto the first one. This may not work well with selections. This function is probably taken from https://daslab.stanford.edu/site_data/docs_pymol_rhiju.pdf """ print("""This returns a list with 7 items: RMSD after refinement Number of aligned atoms after refinement Number of refinement cycles RMSD before refinement Number of aligned atoms before refinement Raw alignment score Number of residues aligned """) AllObj=cmd.get_names("all") for x in AllObj[1:]: #print(AllObj[0],x) subset_tag = '' if isinstance( subset, int ): subset_tag = ' and resi %d' % subset elif isinstance( subset, list ) and len( subset ) > 0: subset_tag = ' and resi %d' % (subset[0]) for m in range( 1,len(subset)): subset_tag += '+%d' % subset[m] elif isinstance( subset, str ) and len( subset ) > 0: subset_tag = ' and %s' % subset values = cmd.align(x+subset_tag,AllObj[0]+subset_tag) print(AllObj[0], x, ' '.join([str(v) for v in values]), '-- RMSD', values[3], ' of ', values[6], 'residues') cmd.zoom()
def render_to_file(fname, top=True, side=True, vesicle=False, zoom_obj="pbcbox", zoom_distance=10): fname = os.path.splitext(fname)[0] cmd.reset() cmd.zoom(zoom_obj, zoom_distance) if vesicle: cmd.turn("z", -90) cmd.move("y", -50) if top: cmd.ray("2048") cmd.png("%s_top.png" % fname) if side: cmd.turn("x", -90) if vesicle: cmd.move("y", 150) cmd.ray("2048") cmd.png("%s_side.png" % fname) cmd.reset() cmd.zoom(zoom_obj, zoom_distance) if vesicle: cmd.turn("z", -90) cmd.move("y", -50)
def _cartoon(selection='all'): """ Draw `selection` in a cartoon style. """ cmd.show('spheres', selection) cmd.set('sphere_scale', 0.23, selection) cmd.hide('sticks', selection) cmd.show('lines', selection) cmd.set('line_as_cylinders', 1) cmd.set('line_radius', 0.08) cmd.set('line_use_shader', 1) cmd.set('valence_mode', 0, selection) cmd.set('valence_size', 0.14, selection) cmd.set('ray_trace_mode', 3) cmd.set('ray_trace_color', 'black') cmd.set_color('lgray', [0.6, 0.6, 0.6]) cmd.color('lgray', 'elem C') cmd.orient(selection) cmd.zoom(selection, 3, complete=1)
def align_all(subset=[]): """ Superimpose all open models onto the first one. This may not work well with selections. This function is taken from rnapdbtool(:P) and before the function is probably taken form: https://daslab.stanford.edu/site_data/docs_pymol_rhiju.pdf """ print("""This returns a list with 7 items: RMSD after refinement Number of aligned atoms after refinement Number of refinement cycles RMSD before refinement Number of aligned atoms before refinement Raw alignment score Number of residues aligned """) AllObj = cmd.get_names("all") for x in AllObj[1:]: #print(AllObj[0],x) subset_tag = '' if isinstance(subset, int): subset_tag = ' and resi %d' % subset elif isinstance(subset, list) and len(subset) > 0: subset_tag = ' and resi %d' % (subset[0]) for m in range(1, len(subset)): subset_tag += '+%d' % subset[m] elif isinstance(subset, str) and len(subset) > 0: subset_tag = ' and %s' % subset values = cmd.align(x + subset_tag, AllObj[0] + subset_tag) print(AllObj[0], x, ' '.join([str(v) for v in values]), '-- RMSD', values[3], ' of ', values[6], 'residues') cmd.zoom()
def de(pdbfile1="IL1B.atm", pdbfile2="MIM_tor.atm", charges=True, logscale=True, dielectric=80., eps=0.1, handle=False): # extract names, and create the 'object' name in the pymol menu window print('22 apr 2020 add ability to save/restore poses') #pdbobj1 = pdbfile1[:-4] pdbobj1 = 'dockeye_prt' cmd.load(pdbfile1, pdbobj1) #pdbobj2 = pdbfile2[:-4] #cmd.load(pdbfile2, pdbobj2) # # Dockeye class reads pdb file upon init pdbobj2 = 'dockeye_lig' obj = Dockeye(pdbfile1, pdbfile2, pdbobj1, pdbobj2, charges, logscale, dielectric, eps, handle) # # but pymol also loads first ligand model for display cmd.load('dockeye_lig.pdb', pdbobj2) os.system('/bin/rm -f dockeye_lig.pdb') # remove any previous temporary files os.system('/bin/rm -f dockeye_mark.*') os.system('/bin/rm -f dockeye_action') cmd.zoom() cmd.do("set auto_zoom, off", echo=0) name = 'dockeye' cmd.load_callback(obj, name) return obj
def images_refocus(images, target): global imagecount global ray global filename global ximage global yimage print "... Images %s - %s:" % (imagecount, imagecount + images - 1) print "Writing %s images zooming to selection:" % images print " %s" % target current_view = cmd.get_view() #get the starting view temporary_view = current_view #make variabe to track interpolation cmd.zoom(target) #zoom to the target selection end_view = cmd.get_view() #get the ending view #get the difference between the start and ending views, divide per step views_difference = tuple(np.subtract(end_view, temporary_view)) diff_per_image = tuple(i / images for i in views_difference) for i in range(0, images): #cycle for number of images #update the interpolating view temporary_view = tuple(np.add(temporary_view, diff_per_image)) cmd.set_view(temporary_view) #print image cmd.png("images/%s_%04d" % (filename, imagecount), ray=ray) #increment imagecounter imagecount = imagecount + 1 cmd.refresh()
def test(self): cmd.set('suspend_updates') cmd.set('depth_cue', 0) cmd.set('ambient', 1) cmd.set('specular', 0) cmd.set('stereo_angle', 10) cmd.pseudoatom() cmd.show_as('sphere') cmd.zoom() cmd.stereo('anaglyph') cmd.set('suspend_updates', 0) wh = (40, 40) cmd.draw(*wh, antialias=0) cmd.sync() img = self.get_imagearray(prior=1) self.assertEqual(wh, img.shape[:2]) # ray tracing and shaders in PyMOL 1.7.6+: # 0xe50000 # 0x00e5e5 # -> delta=26 (0x1a) self.assertImageHasColor('0xff0000', img, delta=0x1a) self.assertImageHasColor('0x00ffff', img, delta=0x1a)
def Load_ProcConvLigand(self, LigandFile, ObjectName, Zoom): Error = 0 try: cmd.delete(ObjectName) cmd.refresh() except: pass auto_zoom = cmd.get("auto_zoom") try: cmd.set("auto_zoom", 0) cmd.load(LigandFile, ObjectName, state=1) cmd.refresh() if Zoom: cmd.zoom(ObjectName) cmd.refresh() except: self.DisplayMessage(' ERROR: Could not load the ligand file in PyMOL', 1) Error = 1 cmd.set("auto_zoom", auto_zoom) return Error
def testAA(self): ''' Make a black/white image and check if gray pixels are found with antialias_shader=1/2 ''' cmd.viewport(100, 100) cmd.set('use_shaders', True) self.ambientOnly() cmd.fragment('gly') cmd.show_as('spheres') cmd.color('white') cmd.zoom() # b/w image, we expect only two color values img = self.get_imagearray() self.assertTrue(len(numpy.unique(img[...,:3])) == 2) for aa in (1, 2): cmd.set('antialias_shader', aa) # smoothed edges, we expect more than two color values img = self.get_imagearray() self.assertTrue(len(numpy.unique(img[...,:3])) > 2)
def output_PNG(this_PDB_file, OUTPUT_FOLDER_PNG, OUTPUT_FOLDER_SESSION): # show complex cmd.hide("all") cmd.bg_color("white") cmd.show("cartoon", "this_complex") # show protein A cmd.set_color("A_interface_color", [167, 244, 66]) # lightgreen cmd.set_color("A_C_term_color", [252, 245, 146]) # pale yellow cmd.color("yellow", "chain A") cmd.color("A_interface_color", "A_interface") cmd.alter("A_center_pseudoatom", "vdw=2") cmd.show("sphere", "A_center_pseudoatom") cmd.color("green", "A_center_pseudoatom") cmd.show("sphere", "A_N_term") cmd.color("yellow", "A_N_term") cmd.show("sphere", "A_C_term") cmd.color("A_C_term_color", "A_C_term") # show protein B cmd.set_color("B_interface_color", [80, 181, 244]) # medium blue cmd.set_color("B_C_term_color", [179, 229, 229]) # pale cyan cmd.color("cyan", "chain B") cmd.color("B_interface_color", "B_interface") cmd.alter("B_center_pseudoatom", "vdw=2") cmd.show("sphere", "B_center_pseudoatom") cmd.color("blue", "B_center_pseudoatom") cmd.show("sphere", "B_N_term") cmd.color("cyan", "B_N_term") cmd.show("sphere", "B_C_term") cmd.color("B_C_term_color", "B_C_term") # nice output cmd.rebuild() cmd.zoom("all") cmd.png("%s/%s.png" % (OUTPUT_FOLDER_PNG, this_PDB_file), quiet=1) # save session cmd.save("%s/%s.pse" % (OUTPUT_FOLDER_SESSION, this_PDB_file))
def load(): cmd.set("valence") r = 0 list = glob("pdb/*/*") (x,y,z)=(0,0,0) start = time.time() count = 1 scale = 100.0 for file in list: cmd.load(file,str(count),quiet=1) cmd.translate([x*scale,y*scale,z*scale],object=str(count)) # cmd.disable(str(count)) atoms = cmd.count_atoms() passed = time.time()-start print "%3d structures/%5.1f sec = %8.1f atom/sec over %6d atoms"%(count,passed,atoms/passed,atoms) count = count + 1 if count>100: break x = x + 1 if x>7: x = 0 y = y + 1 if y>7: y = 0 z = z + 1 if z>9: y = 0 z = z + 1 cmd.zoom() cmd.set("sphere_mode",1) cmd.as("spheres") cmd.rebuild() cmd.set("hash_max",250)
def testAA(self): ''' Make a black/white image and check if gray pixels are found with antialias_shader=1/2 ''' cmd.viewport(100, 100) cmd.set('use_shaders', True) self.ambientOnly() cmd.fragment('gly') cmd.show_as('spheres') cmd.color('white') cmd.zoom() # b/w image, we expect only two color values img = self.get_imagearray() self.assertNumColorsEqual(img, 2) for aa in (1, 2): cmd.set('antialias_shader', aa) # smoothed edges, we expect more than two color values img = self.get_imagearray() self.assertTrue(len(numpy.unique(img[..., :3])) > 2)
def rezoom_tetramer_deo_alignment(target, mobile_pdb): # cmd.viewport(viewport_width_tetramer_alignment(), viewport_height_tetramer_alignment()) cmd.orient(target) cmd.zoom("center", 75) y = tetramer_alignment_centering_y(mobile_pdb) cmd.translate([0,y,0], "(all)") return
def draw_ENM(structure_filepath, script_filepath, structure_name="CAonly", output_dir='.', view=None): """ Draws elastic network model of a structure and saves image. """ cmd.delete('all') cmd.load(structure_filepath, "CAonly") cmd.run(script_filepath) # Set name if structure_name == "CAonly": pass else: cmd.set_name("CAonly", structure_name) # Set view if view == None: cmd.orient() else: cmd.set_view(view) cmd.viewport(width=1200, height=1200) cmd.zoom(complete=1) png_filepath = os.path.join(output_dir, structure_name) + ".png" pse_filepath = os.path.join(output_dir, structure_name) + ".pse" cmd.save(pse_filepath) cmd.set('ray_opaque_background', 0) cmd.png(png_filepath, width=1200, height=1200, ray=1) return (pse_filepath, png_filepath)
def DisplayLigand(self): try: cmd.set("auto_zoom", 0) cmd.load(self.RefLigand, self.LigDisplay, state=self.State) cmd.refresh() # Display the atoms spheres cmd.show('spheres', self.LigDisplay) cmd.refresh() cmd.alter(self.LigDisplay,'vdw=0.25') cmd.rebuild(self.LigDisplay) cmd.refresh() util.cbag(self.LigDisplay) cmd.refresh() cmd.translate(self.Translation,self.LigDisplay) cmd.refresh() cmd.zoom(self.LigDisplay) cmd.refresh() except: self.ErrorCode = 1 cmd.set("auto_zoom", self.auto_zoom) return self.ErrorCode
def zoom_tetramer_any(object_name): # Get a neutral, symmetric view of the molecule(s) # No rotations allowed, since this is generic for many tetramers that may or may not be oriented with respect to 1a8y. # cmd.viewport(viewport_width_tetramer(), viewport_height_tetramer()) cmd.orient(object_name) cmd.zoom(object_name, 45) return
def drawAnnote(self, axis, x, y, annote): if (x, y) in self.drawnAnnotations: markers = self.drawnAnnotations[(x, y)] for m in markers: m.set_visible(not m.get_visible()) self.axis.figure.canvas.draw() else: """ Mark data point and show data """ t = axis.text( x, y, "(%3.2f, %3.2f) - %s" % (x, y, annote), ) m = axis.scatter([x], [y], marker='d', c='r', zorder=100) self.drawnAnnotations[(x, y)] = (t, m) self.axis.figure.canvas.draw() # hide previous structures and load decoy # since native was loaded already, colour is always different cmd.hide("all") cmd.load(self.native_name + '/' + annote + '.pdb') # show, align, and zoom cmd.show("cartoon", self.native_name + ", " + annote) result = cmd.align(self.native_name, annote) cmd.zoom(self.native_name) print("Align of {} and {}, rmsd: {}".format(self.native_name, annote, result[0]))
def align_all( subset = [] ): """ Superimpose all open models onto the first one. This may not work well with selections. """ print """This returns a list with 7 items: RMSD after refinement Number of aligned atoms after refinement Number of refinement cycles RMSD before refinement Number of aligned atoms before refinement Raw alignment score Number of residues aligned """ AllObj=cmd.get_names("all") for x in AllObj[1:]: #print(AllObj[0],x) subset_tag = '' if isinstance( subset, int ): subset_tag = ' and resi %d' % subset elif isinstance( subset, list ) and len( subset ) > 0: subset_tag = ' and resi %d' % (subset[0]) for m in range( 1,len(subset)): subset_tag += '+%d' % subset[m] elif isinstance( subset, str ) and len( subset ) > 0: subset_tag = ' and %s' % subset values = cmd.align(x+subset_tag,AllObj[0]+subset_tag) print AllObj[0], x, ' '.join([str(v) for v in values]), '-- RMSD', values[3], ' of ', values[6], 'residues' cmd.zoom()
def sculpt(self, cleanup=0): if not cleanup: cmd.set("suspend_updates", 1, quiet=1) cmd.disable() cmd.delete("sculpt") cmd.set("sphere_scale", "1.0") cmd.set("sphere_mode", 5) cmd.load("$PYMOL_DATA/demo/pept.pdb", "sculpt") cmd.hide("lines", "sculpt") # cmd.show("sticks","sculpt") cmd.show("spheres", "sculpt") # cmd.set("sphere_transparency","0.75","sculpt") # cmd.set("sphere_color","grey","sculpt") cmd.frame(1) cmd.set("auto_sculpt", 1) cmd.set("sculpting", 1) cmd.sculpt_activate("sculpt") cmd.set("sculpting_cycles", "100") cmd.do("edit_mode") cmd.set("valence", "0.05") cmd.set("suspend_updates", 0, quiet=0) cmd.sculpt_iterate("sculpt") cmd.alter_state(1, "sculpt", "x=x*1.5;y=y*0.1;z=z*1.5") cmd.zoom() cmd.unpick() else: cmd.set("valence", "0") cmd.set("sculpting", 0) cmd.set("auto_sculpt", 0) cmd.delete("sculpt") cmd.mouse()
def zoom_dimer(object_name): # Get a neutral, symmetric view of the molecule(s) # cmd.viewport(viewport_width_dimer(), viewport_height_dimer()) cmd.orient(object_name) cmd.zoom("center", 35) cmd.translate([0,4,0], "(all)") return
def load(): cmd.set("valence") r = 0 list = glob("pdb/*/*") (x, y, z) = (0, 0, 0) start = time.time() count = 1 scale = 100.0 for file in list: cmd.load(file, str(count), quiet=1) cmd.translate([x * scale, y * scale, z * scale], object=str(count)) # cmd.disable(str(count)) atoms = cmd.count_atoms() passed = time.time() - start print "%3d structures/%5.1f sec = %8.1f atom/sec over %6d atoms" % ( count, passed, atoms / passed, atoms) count = count + 1 if count > 100: break x = x + 1 if x > 7: x = 0 y = y + 1 if y > 7: y = 0 z = z + 1 if z > 9: y = 0 z = z + 1 cmd.zoom() cmd.set("sphere_mode", 1) cmd.show_as("spheres") cmd.rebuild() cmd.set("hash_max", 250)
def get_coord(v): if not isinstance(v, str): try: return v[:3] except: return False if v.startswith('['): return cmd.safe_list_eval(v)[:3] try: if cmd.count_atoms(v) == 1: # atom coordinates return cmd.get_atom_coords(v) else: # more than one atom --> use "center" # alt check! if cmd.count_atoms('(alt *) and not (alt "")') != 0: print( "distancetoatom: warning! alternative coordinates found for origin, using center!" ) view_temp = cmd.get_view() cmd.zoom(v) v = cmd.get_position() cmd.set_view(view_temp) return v except: return False
def Load_ProcConvLigand(self, LigandFile, ObjectName, Zoom): Error = 0 try: cmd.delete(ObjectName) cmd.refresh() except: pass auto_zoom = cmd.get("auto_zoom") try: cmd.set("auto_zoom", 0) cmd.load(LigandFile, ObjectName, state=1) cmd.refresh() if Zoom: cmd.zoom(ObjectName) cmd.refresh() except: self.DisplayMessage( ' ERROR: Could not load the ligand file in PyMOL', 1) Error = 1 cmd.set("auto_zoom", auto_zoom) return Error
def vis_cif(cif_path, im_path): import pymol from pymol import cmd cmd.load(cif_path, "mov") cmd.zoom() cmd.png(im_path, 300, 200)
def extra_fit(selection='(all)', reference=None, method='align', zoom=1, quiet=0, _self=cmd, **kwargs): ''' DESCRIPTION Like "intra_fit", but for multiple objects instead of multiple states. ARGUMENTS selection = string: atom selection of multiple objects {default: all} reference = string: reference object name {default: first object in selection} method = string: alignment method (command that takes "mobile" and "target" arguments, like "align", "super", "cealign" {default: align} ... extra arguments are passed to "method" SEE ALSO alignto, cmd.util.mass_align, align_all.py from Robert Campbell ''' zoom, quiet = int(zoom), int(quiet) models = cmd.get_object_list('(%s)' % selection) if reference is None: reference = models[0] models = models[1:] elif reference in models: models.remove(reference) if cmd.is_string(method): if method in cmd.keyword: method = cmd.keyword[method][0] else: print('Unknown method ' + str(method)) raise CmdException for model in models: x = method(mobile='(%s) and model %s' % (selection, model), target='(%s) and model %s' % (selection, reference), **kwargs) if not quiet: if cmd.is_sequence(x): print('%-20s RMS = %8.3f (%d atoms)' % (model, x[0], x[1])) elif isinstance(x, float): print('%-20s RMS = %8.3f' % (model, x)) elif _self.is_dict(x) and 'RMSD' in x: natoms = x.get('alignment_length', 0) suffix = (' (%s atoms)' % natoms) if natoms else '' print('%-20s RMS = %8.3f' % (model, x['RMSD']) + suffix) else: print('%-20s' % (model, )) if zoom: cmd.zoom(selection)
def _testSpectrum_setup(self): cmd.pseudoatom('m1', pos=(-2,0,0)) cmd.pseudoatom('m2', pos=(0,0,0)) cmd.pseudoatom('m3', pos=(2,0,0)) cmd.show_as('spheres') self.ambientOnly() cmd.viewport(40,20) cmd.zoom()
def fatslim_bilayer(): global REF_BEAD REF_BEAD = BILAYER_REF setup() # Load file cmd.load("%s.pdb" % BILAYER) main_obj = "bilayer" cmd.disable(main_obj) traj = load_trajectory("%s.gro" % BILAYER, "%s.ndx" % BILAYER) traj.initialize() frame = traj[0] draw_pbc_box(main_obj) print("Bilayer Loaded!") # Show lipids cmd.create("lipids", "resname DMPC") cmd.hide("lines", "lipids") cmd.show("spheres", "lipids") # Show water cmd.create("water", "resname SOL") cmd.hide("lines", "water") cmd.set("solvent_radius", 2) cmd.show("surface", "water") cmd.color("skyblue", "water") cmd.set("transparency", 0.5, "water") # cmd.rebuild() # cmd.refresh() # Show positions show_positions(frame) # Show directions show_directions(frame) # Show ref bead and its neighbors show_ref(frame) show_ref_ns(frame) # Show normals show_normals(frame) # Identify leaflets show_leaflets(frame) # Calculate and show normals show_leaflet_normals(frame) # Show stuff related to thickness show_thickness(frame) # Show stuff related to APL show_apl(frame) # Zoom on leaflets cmd.zoom("all", 5)
def extra_fit(selection='(all)', reference=None, method='align', zoom=1, quiet=0, _self=cmd, **kwargs): ''' DESCRIPTION Like "intra_fit", but for multiple objects instead of multiple states. ARGUMENTS selection = string: atom selection of multiple objects {default: all} reference = string: reference object name {default: first object in selection} method = string: alignment method (command that takes "mobile" and "target" arguments, like "align", "super", "cealign" {default: align} ... extra arguments are passed to "method" SEE ALSO alignto, cmd.util.mass_align, align_all.py from Robert Campbell ''' zoom, quiet = int(zoom), int(quiet) sele_name = cmd.get_unused_name('_') cmd.select(sele_name, selection) # for speed models = cmd.get_object_list(sele_name) if reference is None: reference = models[0] models = models[1:] elif reference in models: models.remove(reference) else: cmd.select(sele_name, reference, merge=1) if cmd.is_string(method): if method in cmd.keyword: method = cmd.keyword[method][0] else: print('Unknown method:', method) raise CmdException for model in models: x = method(mobile='%s and model %s' % (sele_name, model), target='%s and model %s' % (sele_name, reference), **kwargs) if not quiet: if cmd.is_sequence(x): print('%-20s RMS = %8.3f (%d atoms)' % (model, x[0], x[1])) elif isinstance(x, float): print('%-20s RMS = %8.3f' % (model, x)) elif isinstance(x, dict) and 'RMSD' in x: natoms = x.get('alignment_length', 0) suffix = (' (%s atoms)' % natoms) if natoms else '' print('%-20s RMS = %8.3f' % (model, x['RMSD']) + suffix) else: print('%-20s' % (model,)) if zoom: cmd.zoom(sele_name) cmd.delete(sele_name)
def _testSpectrum_setup(self): cmd.pseudoatom('m1', pos=(-2,0,0)) cmd.pseudoatom('m2', pos=(0,0,0)) cmd.pseudoatom('m3', pos=(2,0,0)) cmd.show_as('spheres') cmd.set('ambient', 1) cmd.set('specular', 0) cmd.set('reflect', 0) cmd.set('direct', 0) cmd.viewport(40,20) cmd.zoom()
def create(mol_name): """ create the defined molecule """ if os.path.isfile('%s_matrix.dat' % mol_name): residues, bonds = read_input('%s_matrix.dat' % mol_name) builder(residues, bonds, mol_name) to_state.set(cmd.count_states(sel0_value.get())) cmd.zoom() cmd.util.chainbow(mol_name) else: tkMessageBox.showerror("FileNotFound", "You should add residues\ before creating a molecule.")
def test2095(self, bg_gradient, opaque_background, hasColor): cmd.load(self.datafile("1oky-frag.pdb")) cmd.zoom(buffer=20) cmd.set("bg_gradient", bg_gradient) cmd.set("bg_rgb_top", "blue") cmd.set("bg_rgb_bottom", "blue") cmd.set("opaque_background", opaque_background) cmd.color("red") if hasColor: self.assertImageHasColor('blue', self.get_imagearray(width=100, height=100, ray=1)) else: self.assertImageHasNotColor('blue', self.get_imagearray(width=100, height=100, ray=1))
def drawAnnote(self, axis, x, y, annote): # EDIT: remove last markers for markers in self.drawnAnnotations.itervalues(): for m in markers: # tuple #m.set_visible(not m.get_visible()) m.remove() self.axis.figure.canvas.draw() self.drawnAnnotations = {} if (x,y) in self.drawnAnnotations: markers = self.drawnAnnotations[(x,y)] for m in markers: m.set_visible(not m.get_visible()) self.axis.figure.canvas.draw() else: """ Mark data point and show data """ t = axis.text(x,y, "(%3.2f, %3.2f)"%(x,y), ) m = axis.scatter([x],[y], marker='d', c='r', zorder=100) self.drawnAnnotations[(x,y)] =(t,m) self.axis.figure.canvas.draw() """Your code here!""" cmd.delete('all') # load pdb files pdb_ext = '.pdb' cmd.load(self.native) cmd.load(os.path.join(self.pdb_dir, annote + pdb_ext)) # label cmd.pseudoatom('foo') cmd.hide('all') #cmd.label('foo', '"'+annote+'"') # color native_name = os.path.splitext(os.path.basename(self.native))[0] cmd.color('green', native_name) cmd.set('label_color', 'green', native_name) cmd.color('blue', annote) cmd.set('label_color', 'blue', annote) cmd.set('label_color', 'blue', 'foo') # background cmd.bg_color("white") cmd.set("depth_cue", 0) cmd.set("ray_trace_fog", 0) # view cmd.show(representation='cartoon') # alignment cmd.super(annote, native_name) # zoom cmd.zoom()
def testAngleColor(self): cmd.fragment('ala') cmd.color('blue') cmd.angle('ang01', 'index 8', 'index 5', 'index 2') cmd.hide('label') cmd.set('fog', '0') cmd.set('ambient', '1') cmd.set('angle_color', 'red') cmd.set('dash_gap', '0') cmd.zoom() #need to check to make sure screen image has red in it img_array = self.get_imagearray(width=100, height=100, ray=0) self.assertImageHasColor('red', img_array, delta=[10,0,0])
def testDihedralColor(self): cmd.fragment('ala') cmd.color('blue') cmd.dihedral('dih01', 'index 8', 'index 5', 'index 2', 'index 1') cmd.hide('label') cmd.set('fog', '0') cmd.set('ambient', '1') cmd.set('dihedral_color', 'red') cmd.zoom() #need to check to make sure screen image has red in it img_array = self.get_imagearray(width=100, height=100, ray=0) self.assertImageHasColor('red', img_array)
def _gpssLoadPdb(pdbCode,reinitialize): pdbCode = pdbCode.lower() GPSSpdbCode = 'GPSS_' + pdbCode _gpssVersionCheck('0.3'); if cmd.get_names().count(GPSSpdbCode) < 1: if reinitialize==1: cmd.do('reinitialize') pdbFile = urllib2.urlopen('http://gpss.mcsg.anl.gov/webservices/'+ 'gpssServerPymol.php?pdbId='+ pdbCode + '&mode=pdbFile').read() if pdbFile: pdbFile = urllib2.urlopen('http://gpss.mcsg.anl.gov/webservices/'+ 'gpssServerPymol.php?pdbId='+ pdbCode + '&mode=pdbFile') cmd.read_pdbstr(pdbFile.read(),GPSSpdbCode) # Make structure pretty # David Borhani, 14-JAN-2009 # Changed to color by chain, show lines only, keep user's bg color. #cmd.do('set bg_rgb=[1,1,1]') #cmd.do('hide everything') cmd.hide('everything', GPSSpdbCode) #cmd.do('dss') cmd.dss(GPSSpdbCode) #util.cbc(selection='(GPSS-' + pdbCode + ')',first_color=7,quiet=1,legacy=1,_self=cmd) #sel_string = '("' + GPSSpdbCode + '")' #cmd.do('util.cbc(selection=' + sel_string + ',first_color=9,quiet=1,legacy=1)') cmd.do('util.cbc(selection=("' + GPSSpdbCode + '"),first_color=9,quiet=1,legacy=1)') #cmd.do('show lines, ' + GPSSpdbCode) cmd.show('lines', GPSSpdbCode) #cmd.do('show cartoon, ' + GPSSpdbCode) #cmd.do('color gray') return True else: tkMessageBox.showerror('GPSS ', pdbCode + ' was not found on the GPSS server.') #cmd.do('zoom GPSS-'+pdbCode) cmd.zoom(GPSSpdbCode, animate=0) else: return True
def loadPackingPDB(file,name=None,native=None): """ usage: loadPackingPDB <file> , [<name for object>] loads a foo_packing.pdb file and colors it all pretty-like creates two selections along with the loaded object called NAMEcavities and NAMEprotein which are the heteratoms representing holes and everything else, respectively. Names can get pretty long, by pymol lets you do good stuff like "select NA*cav*", which will match a selection called NAMEISREALLYLONGcavities. """ if name is None: name = name = os.path.basename(file) if name.endswith('.gz'): name = name[:-3] if name.endswith('.pdb'): name = name[:-4] if name.endswith('.'): name = name[:-1] if name.endswith("_packing"): name = name[:-8] zload(file,name) cmd.hide('everything',name) if native is not None: cmd.align(name,native) cmd.zoom(native) useRosettaRadii() cavselname = name+"cavities" protselname = name+"protein" cmd.select(cavselname, "resn CAV and b > 0.1 and %s"%(name) ) cmd.select(protselname,"(not resn CAV) and %s"%(name) ) useTempRadii(cavselname) useOccColors(cavselname) cmd.color("white",protselname) cmd.show('spheres', cavselname ) cmd.show("cartoon",protselname) cmd.show("lines",protselname) cmd.select("none") cmd.delete("sele*") cmd.move('z',-50) return name
def mark_res(): """ mark_res <pdb_file> <highlight_residue> select the chain and residue that ICP dipeptide locate and highlight it. """ #list of pdb id, chain id, and residues informations for ICP. the lower case pdbs are from blast, #upercase PDBs are from SGD pdb homologous search. pdb_input_lists = [('1fa0', 'A', '177-178', '117-147'), ('1u5t', 'A', '42-43'), ('1yke', 'A', '103-104', '43-73'), ('2b1e', 'A', '294-295', '234-264'), ('2PFV', 'A', '294-295', '234-264'), ('1MNM', 'C', '177-178', '117-147'), ('2ckz', 'D', '11-12'), ('2pk9', 'D', '150-151+245-246', '90-120+185-215'), ('2pmi', 'D', '150-151+245-246', '90-120+185-215'), ('2xfv', 'A', '7-8'), ('3esl', 'A', '191-192', '131-161'), ('3n7n', 'E', '20-21'), ('3t5v', 'E', '288-289', '228-258'), ('4bh6', 'A', '365-366', '305-335')] #iterate pdbs for pdb_info in pdb_input_lists: pdb_id = pdb_info[0] chain_id = pdb_info[1] res_id = pdb_info[2] up_region = pdb_info[3] if len(pdb_info) == 4 else '0' pdb_file = pdb_id + ".pdb" chain_selection = "chain " + chain_id res_selection = "res " + res_id up_region_selection = "res " + up_region #command chains to process the pdb files. cmd.load(pdb_file) cmd.remove("solvent") cmd.color("gray80") cmd.show("cartoon") cmd.hide("line") cmd.select("monomer", chain_selection) cmd.color("cyan", "monomer") cmd.select("icp_dipep", chain_selection + " and " + res_selection) cmd.select("up_region", chain_selection + " and " + up_region_selection) cmd.select("none") cmd.color("red", "icp_dipep") cmd.color("yellow", "up_region") cmd.zoom(chain_selection) # cmd.zoom("all") cmd.png(pdb_id + ".png") cmd.save(pdb_id + ".pse") cmd.delete("all")
def angle_between_helices(selection1, selection2, method='helix_orientation', visualize=1, quiet=0): ''' DESCRIPTION Calculates the angle between two helices USAGE angle_between_helices selection1, selection2 [, method [, visualize]] ARGUMENTS selection1 = string: atom selection of first helix selection2 = string: atom selection of second helix method = string: function to calculate orientation {default: helix_orientation} or int: 0: helix_orientation, 1: helix_orientation_hbond, 2: loop_orientation, 3: cafit_orientation visualize = 0 or 1: show fitted vector as arrow {default: 1} SEE ALSO helix_orientation, helix_orientation_hbond, loop_orientation, cafit_orientation ''' visualize, quiet = int(visualize), int(quiet) methods = { '0': helix_orientation, '1': helix_orientation_hbond, '2': loop_orientation, '3': cafit_orientation, } methods.update([(x.__name__, x) for x in methods.values()]) try: orientation = methods[str(method)] except KeyError: print 'no such method:', method raise CmdException if not quiet: print 'Using method:', orientation.__name__ cen1, dir1 = orientation(selection1, visualize, quiet=1) cen2, dir2 = orientation(selection2, visualize, quiet=1) angle = cpv.get_angle(dir1, dir2) angle_deg = math.degrees(angle) if not quiet: print 'Angle: %.2f deg' % (angle_deg) if visualize: cmd.zoom('(%s) or (%s)' % (selection1, selection2), buffer=2) return angle_deg
def testZoom(self): views = { 0: (1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, -30.417539596557617, 1.666666865348816, -1.6666665077209473, 0.0, 23.981420516967773, 36.853660583496094, -20.0), 1: (1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, -14.178204536437988, 0.0, 0.0, 0.0, 11.178204536437988, 17.178203582763672, -20.0), 2: (1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, -14.178204536437988, 4.999999046325684, 0.0, 0.0, 11.178204536437988, 17.178203582763672, -20.0), } self._testZoomGeneric(cmd.zoom, views) cmd.zoom('all', 2.0, 3, 1) self.assertViewIs((1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, -25.093609, 0.0, -5.0, 0.0, 19.783993, 30.403225, -20.0))
def ie_build_file(fname, align='true', ortho='true', hide='true', zoom='true', col='[0.5, 0.5, 0.5]', scale='1'): if to_bool(ortho): cmd.set('orthoscopic', 'true') cmd.load(fname) if to_bool(align): object_list = cmd.get_names() target = object_list.pop() for obj in object_list: cmd.align(obj, target) if to_bool(hide): cmd.hide('everything') ie_build_all(col, scale) if to_bool(zoom): cmd.zoom()
def save_images(title=1): cmd.set( 'ray_opaque_background', 0 ) for x in cmd.get_names( 'all' ): rg = rgyrate( x , 1 ) cmd.disable( 'all' ) cmd.enable( x ) cmd.zoom( x, buffer=0.0, state=0, complete=1 ) if title: cmd.set( 'label_size', 25 ) #cmd.set( 'label_position', (0,-25,0) ) cmd.set( 'label_position', (0,(-10-rg),0) ) cmd.pseudoatom( 'pa', label=x ) cmd.zoom( 'visible', buffer=5, state=0, complete=1 ) cmd.png( x+'.png', dpi=300, ray=1 ) cmd.delete( 'pa' )
def load(): cmd.set("valence") cmd.unset("auto_zoom") cmd.zoom("center",100) r = 0 list = glob("pdb/*/*") # while list[0]!="pdb/f8/pdb1f8u": # list.pop(0) for file in list: try: cmd.delete('pdb') cmd.load(file,'pdb') cmd.set_title('pdb',1,os.path.split(file)[-1]) cmd.refresh() except: traceback.print_exc()
def set_mpobj(val): mpobj.set(val) cmd.zoom(val, 3) logger.debug('mpobj set to {}'.format(val)) # Get active flipkin flipkin = self.flipkin_radio.getvalue() o = main.get_object(val) if o.kin[flipkin] is not None: logger.debug('populating flips group...') populate_flips_grp(flipkin) else: msg = "No {} for object {}...clearing flips.".format( flipkin, val) logger.debug(msg) clear_child_widgets(flips_grp.interior())
def show_fft(file="map_coeff.pickle", map_level=3.0): cmd.delete("all") map_coeff = easy_pickle.load(file) map_coeff.show_summary() fft_map = map_coeff.fft_map( symmetry_flags=maptbx.use_space_group_symmetry) print "map gridding:", fft_map.n_real() show_map(fft_map.unit_cell(), fft_map.real_map(), "fft_map", map_level) clusters = fft_map.tags().peak_search( parameters=maptbx.peak_search_parameters( min_distance_sym_equiv=3.0, max_clusters=10), map=fft_map.real_map()).all() show_peaks(fft_map.unit_cell(), clusters) cmd.zoom('all', 15.0) # zoom with additional border of 15 Ang. print
def sa(intra=False,rainbow=True): """ Superimpose all open models onto the first one. This may not work well with selections. Option intra can be set to True to enable intra_fit first, for working with multi-state (nmr) pdbs. [Thanks to Kyle Beauchamp for this one] """ AllObj=cmd.get_names("all") for x in AllObj: print(AllObj[0],x) if intra==True: cmd.intra_fit(x) if rainbow==True: cmd.util.chainbow(x) cmd.align(x,AllObj[0]) cmd.zoom()
def angle_between_helices(selection1, selection2, method="helix_orientation", visualize=1, quiet=0): """ DESCRIPTION Calculates the angle between two helices USAGE angle_between_helices selection1, selection2 [, method [, visualize]] ARGUMENTS selection1 = string: atom selection of first helix selection2 = string: atom selection of second helix method = string: function to calculate orientation {default: helix_orientation} or int: 0: helix_orientation, 1: helix_orientation_hbond, 2: loop_orientation, 3: cafit_orientation visualize = 0 or 1: show fitted vector as arrow {default: 1} SEE ALSO helix_orientation, helix_orientation_hbond, loop_orientation, cafit_orientation """ visualize, quiet = int(visualize), int(quiet) methods = {"0": helix_orientation, "1": helix_orientation_hbond, "2": loop_orientation, "3": cafit_orientation} methods.update([(x.__name__, x) for x in list(methods.values())]) try: orientation = methods[str(method)] except KeyError: print("no such method: " + str(method)) raise CmdException if not quiet: print("Using method: " + orientation.__name__) cen1, dir1 = orientation(selection1, visualize, quiet=1) cen2, dir2 = orientation(selection2, visualize, quiet=1) angle = cpv.get_angle(dir1, dir2) angle_deg = math.degrees(angle) if not quiet: print("Angle: %.2f deg" % (angle_deg)) if visualize: cmd.zoom("(%s) or (%s)" % (selection1, selection2), buffer=2) return angle_deg