def vis(res, path_prefix, c=["firebrick", "forest", 'purple', 'salmon', "gold", "red"]): for ind, r in enumerate(res): for a in r.atoms: cmd.show("spheres", "id " + str(a.id)) cmd.set("sphere_color", c[ind], "id " + str(a.id)) cmd.distance("d" + str(ind), "id " + str(r.atoms[0].id), "id " + str(r.atoms[1].id)) cmd.hide("labels") cmd.set("grid_slot", -2, "d" + str(ind)) cmd.ray(1200) time.sleep(2) cmd.set("grid_mode", 0) cmd.png(path_prefix + "_restraints.png") #cmd.set("grid_mode", 1) cmd.move("zoom", -10) cmd.ray(1200, ) time.sleep(4) cmd.png(path_prefix + "_grid_restraints.png") cmd.set("grid_mode", 0) cmd.hide("spheres") cmd.delete("d*")
def save_image_closeup(filename, width=ray_width_closeups(), height=ray_height_closeups()): cmd.bg_color("white") # cmd.ray(ray_width_closeups(), ray_height_closeups()) cmd.ray(width, height) cmd.png("./output/" + filename + ".png", dpi=dpi()) cmd.bg_color("black") return
def stereo_ray(filename, width=0, height=0, quiet=1): ''' DESCRIPTION "stereo_ray" ray-traces the current scene twice (separated by a six-degree rotation around the y axis) and saves a pair of images that can be combined in any image manipulation software to form a stereoimage. The first argument, the output file name, is mandatory. The second and third arguments, the size of the image, are not. If the width is given, the height will be calculated. USAGE stereo_ray filename [, width [, height]] EXAMPLE stereo_ray output, 1000, 600 stereo_ray secondImage.png ''' if filename.lower().endswith('.png'): filename = filename[:-4] cmd.ray(width, height, angle=-3) cmd.png(filename + "_r", quiet=quiet) cmd.ray(width, height, angle=3) cmd.png(filename + "_l", quiet=quiet)
def stereo_ray(filename, width=0, height=0, quiet=1): """ DESCRIPTION "stereo_ray" ray-traces the current scene twice (separated by a six-degree rotation around the y axis) and saves a pair of images that can be combined in any image manipulation software to form a stereoimage. The first argument, the output file name, is mandatory. The second and third arguments, the size of the image, are not. If the width is given, the height will be calculated. USAGE stereo_ray filename [, width [, height]] EXAMPLE stereo_ray output, 1000, 600 stereo_ray secondImage.png """ if filename.lower().endswith(".png"): filename = filename[:-4] cmd.ray(width, height, angle=-3) cmd.png(filename + "_r", quiet=quiet) cmd.ray(width, height, angle=3) cmd.png(filename + "_l", quiet=quiet)
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 test(self): cmd.fragment('ala') cmd.ray(100, 100) img = self.get_imagearray() # cmd.png without optional arguments # bug was: ray tracing twice, second time would not be 100x100 self.assertEqual(img.shape[:2], (100,100))
def abl(*files, **kwargs): MdsPymol.reset(options) if 'optionsFile' in kwargs: execfile(kwargs['optionsFile'], globals(), locals()) for file in files: print "Processing file '%s'." % file fileOptions = perMapOptions.get(file, {}) # Add a CGO prefix if we have multiple files and a prefix was not given. if len(files) > 1 and 'cgo prefix' not in fileOptions: basename, _ = os.path.splitext(os.path.basename(file)) fileOptions['cgo prefix'] = basename + '_' mapOptions = defaultMapOptions.copy() restrictedUpdate(mapOptions, fileOptions) ACmap(file, mapOptions) # Process global options. cmd.clip('far', -20.0) #cmd.clip('near', 100.0) if options['axes compute']: Axes(options) if options['base grid compute']: BaseGrid(options) if options['view']: cmd.set_view(options['view']) if options['ray']: cmd.ray() if options['png file']: cmd.png(options['png file']) if options['quit']: cmd.quit()
def saveMultiplepng(pnamein, nbstates): finish_launching() for state in range(0,nbstates): print(state, nbstates) finish_launching() pfilin = pnamein + "_state" + str(state) + ".pdb" print (pfilin) cmd.load(pfilin, "state" + str(state)) cmd.hide("everything", "all") for state in range(0, nbstates): cmd.show("surface", selection="state" + str(state)) cmd.set("transparency", value=0.4) cmd.show("cartoon", selection="state" + str(state)) cmd.spectrum("b", "chocolate_firebrick_red_tv_red_deepsalmon_darksalmon_salmon_lightpink_white", selection="all", minimum=0, maximum=100) cmd.select("lig" + str(state), "resn UNK and state" + str(state)) cmd.show("stick", selection="lig" + str(state)) cmd.bg_color("white") cmd.ray(2000, 2000) cmd.save(pnamein + "_state" + str(state) + ".png", selection="state" + str(state)) cmd.hide("everything", "all") cmd.quit()
def surfback(width,height,color="gray",showcartoon=True,dname=""): #if (cmd.get("bg_image_filename")==None): cmd.set("bg_image_filename",None) cmd.hide("") cmd.set("fog", 0) cmd.set("reflect", 0) cmd.set("ambient",1) cmd.set("ray_trace_mode", 0) cmd.show("surface") cmd.set("surface_color",color) cmd.set("spec_reflect",0) cmd.ray(width,height) # I want below to work with tmpdir but, it fails. So this script makes unwanted tmpfile to dir named as dname cmd.png(dname+"surf.png") cmd.do("ls " + dname) cmd.do("ls " + dname+"surf.png") #cmd.load_png(dname+"surf.png") time.sleep(0.01) cmd.set("bg_image_filename",dname+"surf.png") cmd.set("bg_image_mode",0) if (showcartoon): cmd.hide("") cmd.show("cartoon") cmd.color("white") cmd.set("ray_trace_mode", 3) cmd.set("ambient", 1) cmd.set("reflect",0) cmd.set("valence", 0) cmd.set("spec_reflect",0) cmd.set("ray_trace_color", "gray0") #cmd.ray(n,n) #cmd.png("/ print("Ray your image in the same aspect ratio as you specified in surfback")
def test(self): cmd.fragment('ala') cmd.ray(100, 100) img = self.get_imagearray() # cmd.png without optional arguments # bug was: ray tracing twice, second time would not be 100x100 self.assertEqual(img.shape[:2], (100, 100))
def take_screenshot(params, pdb_file_name, protein_number, step_number): print("") print("SCREENSHOT! protein #", protein_number, pdb_file_name, " step ", step_number, " with ", cmd.count_atoms("all"), " atoms") screenshot_path = "./results/{}/screenshots/{}-{}/{}-{}.png".format(params.run_time_stamp, pdb_file_name, protein_number, pdb_file_name, step_number) cmd.ray() # cmd.zoom("all") cmd.center("all") cmd.png(screenshot_path)
def _test_recall(self): cmd.scene('s1', 'recall') cmd.ray(1, 1) # force scene update self.assertEqual(['m3'], cmd.get_object_list('(visible)')) self.assertEqual(['m3'], cmd.get_object_list('(enabled)')) cmd.enable('g1') cmd.ray(1, 1) # force scene update self.assertEqual(['m1', 'm3'], cmd.get_object_list('(visible)')) self.assertEqual(['m1', 'm3'], cmd.get_object_list('(enabled)'))
def rotation_series(axis, increment, width, height, filename, with_centering): if (increment == 0): max_turns = 1 else: max_turns = (360/increment) + 1 for x in range(max_turns): if x > 0: cmd.rotate(axis, increment) if with_centering: cmd.center("(all)") cmd.ray(width, height) cmd.png(filename + "_" + str(x * increment) + ".png", dpi=dpi()) return
def save_image( width = 1920, height = 1080, selection = '(all)', format = 'png', state = -1, prefix = os.path.join(Windows_Desktop() or _Nix_Desktop(), 'PyMOL'), renderer = -1, shift = 0.0): cmd.ray(width, height, renderer, shift) for path in pathes(prefix, format): if not os.path.exists(path): cmd.save(path, selection, state, format) break
def test(self): cmd.pseudoatom('m1') cmd.pseudoatom('m2') cmd.pseudoatom('m3') cmd.group('g1', 'm1') cmd.disable('g1') cmd.disable('m2') cmd.ray(1, 1) # force scene update cmd.scene('s1', 'store') self._test_recall() cmd.disable('*') self._test_recall() cmd.enable('*') self._test_recall()
def save_image(width=1920, height=1080, selection='(all)', format='png', state=-1, prefix=os.path.join(Windows_Desktop() or _Nix_Desktop(), 'PyMOL'), renderer=-1, shift=0.0): cmd.ray(width, height, renderer, shift) for path in pathes(prefix, format): if not os.path.exists(path): cmd.save(path, selection, state, format) break
def makecartoon(): cmd.color('black', 'name C') cmd.color('yellow', 'name S') cmd.hide('lines', 'all') cmd.set('stick_radius', 0.1) cmd.set('sphere_scale', 0.25) cmd.set('sphere_scale', 1, 'name au') cmd.set('sphere_scale', 1, 'name ag') cmd.set('antialias', 2) cmd.set('opaque_background', 0) cmd.set('ray_trace_gain', 5) cmd.set('depth_cue', 0) cmd.show('sticks', 'all') cmd.show('spheres', 'all') cmd.ray(2400, 1800)
def load(): r = 0 rep = ["lines", "sticks", "spheres", "dots", "ribbon", "cartoon"] list = glob("pdb/*/*") list = map(lambda x: (random.random(), x), list) list.sort() list = map(lambda x: x[1], list) # list = [ "pdb/rb/pdb0rbs.noc" ] + list # while list[0]!="pdb/f8/pdb1f8u": # list.pop(0) for file in list: try: print file cmd.delete('pdb') cmd.load(file, 'pdb') cmd.orient('pdb') cmd.color('red', 'ss h') cmd.color('yellow', 'ss s') cmd.hide() if cmd.count_atoms() < 15000: cmd.show(rep[r], "all") elif cmd.count_atoms() < 50000: cmd.show("cartoon", "all") else: cmd.show("lines", "all") r = r + 1 if r >= len(rep): r = 0 sys.__stderr__.write(".") sys.__stderr__.flush() n = cmd.count_states() cmd.ray(160, 120) cmd.dirty() time.sleep(0.1) if n > 1: sys.__stderr__.write("\n") sys.__stderr__.flush() except: traceback.print_exc()
def stereo_ray(output="", width="", height=""): """ DESCRIPTION "stereo_ray" ray-traces the current scene twice (separated by a six-degree rotation around the y axis) and saves a pair of images that can be combined in any image manipulation software to form a stereoimage. The first argument, the output file name, is mandatory. The second and third arguments, the size of the image, are not. If the width is given, the height will be calculated. USAGE stereo_ray filename [, width [, height]] EXAMPLE stereo_ray output, 1000, 600 stereo_ray secondImage.png """ if output == "": print "no output filename defined\n" print "try: 'stereo_ray filename'" return -1 # abort if no output file name given if width == "": width, height = cmd.get_session()["main"][0:2] # get dimensions from viewer if not given elif height == "": oldWidth, oldHeight = cmd.get_session()["main"][0:2] height = int(width) * oldHeight / oldWidth # calculate height from proportions of viewer if # only width is given cmd.ray(width, height, angle=-3) cmd.png(output + "_r") cmd.ray(width, height, angle=3) cmd.png(output + "_l")
def stereo_ray(output='', width='', height=''): if output == '': print 'no output filename defined\n' print 'try: \'stereo_ray filename\'' return -1 # abort if no output file name given if width == '': width, height = cmd.get_session()['main'][0:2] # get dimensions from viewer if not given elif height == '': oldWidth, oldHeight = cmd.get_session()['main'][0:2] height = int(width) * oldHeight / oldWidth # calculate height from proportions of viewer if # only width is given cmd.ray(width, height, angle=-3) cmd.png(output + "_r") cmd.ray(width, height, angle=3) cmd.png(output + "_l")
def stereo_ray(output='', width='', height=''): if output == '': print 'no output filename defined\n' print 'try: \'stereo_ray filename\'' return -1 # abort if no output file name given if width == '': width,height = cmd.get_session()['main'][0:2] # get dimensions from viewer if not given elif height == '': oldWidth,oldHeight = cmd.get_session()['main'][0:2] height = int(width)*oldHeight/oldWidth # calculate height from proportions of viewer if # only width is given cmd.ray(width, height, angle=-3) cmd.png(output+"_r") cmd.ray(width, height, angle=3) cmd.png(output+"_l")
def load(): r = 0 rep = [ "lines","sticks","spheres","dots","ribbon","cartoon" ] list = glob("pdb/*/*") list = map(lambda x:(random.random(),x),list) list.sort() list = map(lambda x:x[1],list) # list = [ "pdb/rb/pdb0rbs.noc" ] + list # while list[0]!="pdb/f8/pdb1f8u": # list.pop(0) for file in list: try: print file cmd.delete('pdb') cmd.load(file,'pdb') cmd.orient('pdb') cmd.color('red','ss h') cmd.color('yellow','ss s') cmd.hide() if cmd.count_atoms()<15000: cmd.show(rep[r],"all") elif cmd.count_atoms()<50000: cmd.show("cartoon","all") else: cmd.show("lines","all") r = r + 1 if r>=len(rep): r=0; sys.__stderr__.write(".") sys.__stderr__.flush() n = cmd.count_states() cmd.ray(160,120) cmd.dirty() time.sleep(0.1) if n>1: sys.__stderr__.write("\n") sys.__stderr__.flush() except: traceback.print_exc()
def images(B): #cmd.do("cd {}".format(B)) pdb_list = glob.glob("*.pdb") for pdb in pdb_list: cmd.load(pdb) cmd.run("/usr/local/bin/all_against_all.py") cmd.select("all_ps", "name PS1+PS2+PS3") cmd.do( "align_all_to_all(selection='all_ps',cutoff=0,cycles=0,full_matrix=1,method='align')" ) cmd.remove("het") cmd.remove("all_ps") cmd.show("sticks", "all") cmd.hide("sticks", "all_ps") cmd.hide("sphere", "all_ps") cmd.set("sphere_scale", 0.30, "all_ps") cmd.orient("all") cmd.multisave("{}.pdb".format(B)) cmd.set("ray_opaque_background", 0) cmd.ray(2400) cmd.set("antialias", 1) cmd.png("{}.png".format(B), 1200, 1200, 300) cmd.quit()
def run(): # get form data height = form.input_height.value() width = form.input_width.value() dpi = form.input_dpi.value() filename = form.input_filename.text() units = form.input_units.currentText() # calculate dots per centimeter or inch if units == 'cm': dots_per_unit = dpi * 2.54 else: dots_per_unit = dpi # convert image size to pixels width *= dots_per_unit height *= dots_per_unit # render the image if filename: cmd.png(filename, width, height, dpi=dpi, ray=1, quiet=0) else: cmd.ray(width, height, quiet=0) print('No filename selected, only rendering on display')
def test(self): cmd.pseudoatom('m1') cmd.mset('1x1') cmd.create('m2', 'm1') cmd.ray() v = cmd.get_object_matrix('m2') self.assertArrayEqual(v, [ 1., 0., 0., 0., 0., 1., 0., 0., 0., 0., 1., 0., 0., 0., 0., 1., ], 0.001, 'object matrix not identity')
cmd.color("atomic", "not element C") cmd.hide("licorice", "hydro") # general settings cmd.bg_colour("white") cmd.set("ambient", 0.4) cmd.set("antialias", 1) cmd.set("ortho", 1) cmd.set("sphere_mode", 5) cmd.set("ray_trace_mode", 1) cmd.set("cartoon_fancy_helices", 1) cmd.set("cartoon_highlight_color", "grey30") # draw the grid ## select the range cmd.select('20A', 'ROCK1_ligand expand 20') cmd.load('drawgridbox.pml') # view cmd.set_view (( 0.003532045, -0.998905182, -0.046578705, 0.942174196, -0.012283626, 0.334894955, -0.335102588, -0.045066781, 0.941101432, -0.000204355, 0.000496300, -208.231918335, 53.537849426, 102.745925903, 29.107488632, 130.434631348, 285.912689209, -20.000000000 )) # save pymol session cmd.save(HERE / "pymol_3d_grid_encoding.pse") cmd.ray(800, 800) cmd.png(DATA / "pymol_3d_grid_encoding.png")
def make_figure(output='', mode='',size=900,opaque='transparent'): """ AUTHOR Martin Christen DESCRIPTION "make_figure" creates publication-quality figures of the current scene. It understands several predefined "modes" and sizes. USAGE make_figure filename [, mode] [, size (default=900 pixels)] [,opaque] ARGUMENTS mode = string: type of desired figure (single, fb, sides, stereo or -nothing-) size = integer: size of the figure in pixels OR # panels (if <= 12) opaque = specify an opaque background. By default, the script makes the background transparent. EXAMPLES make_figure output make_figure output, single, 975, opaque make_figure output, fb, 2 make_figure output, sides,4 make_figure output, stereo NOTES "single" mode makes a single 300 dpi figure "fb" mode makes TWO 300 dpi figure ("front" and "back", rotating by 180 degrees about y) "sides" mode makes FOUR 300 dpi figures ("front" "left" "right" and back, rotating by 90 degrees clockwise about y) "stereo" generates two 300 dpi, 750 px figures ("L" and "R", to be combined as a stereo image) If you specify the stereo mode, the size argument is IGNORED. If no mode argument is given, the script generates quick figures for general use: TWO figures (front and back) at 300 x 300 px, 72 dpi. Size is interpreted as pixels, except if the number is ridiculously small (<=12), in which case the script as "number of panels" to make. Edit the script manually to define corresponding values. """ #define sizes here (in pixels) panel1 = 1800 panel2 = 1350 panel3 = 900 panel4 = 900 panel5 = 750 panel6 = 750 panel7 = 675 panel8 = 675 panel9 = 600 panel10 = 585 panel11 = 585 panel12 = 585 #verify size is an integer number and convert to pixels size = int(size) if size > 12: pixels = size elif size == 1: pixels = panel1 elif size == 2: pixels = panel2 elif size == 3: pixels = panel3 elif size == 4: pixels = panel4 elif size == 5: pixels = panel5 elif size == 6: pixels = panel6 elif size == 7: pixels = panel7 elif size == 8: pixels = panel8 elif size == 9: pixels = panel9 elif size == 10: pixels = panel10 elif size == 11: pixels = panel11 elif size == 3: pixels = panel12 #change background cmd.unset('opaque_background') if opaque == 'opaque': cmd.set('opaque_background') #apply mode if output == '': print 'no output filename defined\n' print 'try: \'make_figure filename\'' return -1 # abort if no output file name given if mode =='': cmd.set('surface_quality',1) cmd.set('opaque_background') cmd.png(output+"_back_quick",300,300,dpi=72) cmd.turn('y',180) cmd.png(output+"_front_quick",300,300,dpi=72) cmd.turn('y',180) cmd.set('surface_quality',0) # make front and back figures for quick mode elif mode == 'single': cmd.set('surface_quality',1) cmd.set('ray_shadow',0) cmd.ray(pixels, pixels) cmd.png(output, dpi=300) cmd.set('surface_quality',0) # make a figure for single mode elif mode == 'fb': cmd.set('surface_quality',1) cmd.set('ray_shadow',0) cmd.ray(pixels, pixels) cmd.png(output+"_front", dpi=300) cmd.turn('y',180) cmd.ray(pixels, pixels) cmd.png(output+"_back", dpi=300) cmd.turn('y',180) cmd.set('surface_quality',0) # make front and back figures for single mode elif mode == 'sides': cmd.set('surface_quality',1) cmd.set('ray_shadow',0) cmd.ray(pixels, pixels) cmd.png(output+"_1", dpi=300) cmd.turn('y',90) cmd.ray(pixels, pixels) cmd.png(output+"_2", dpi=300) cmd.turn('y',90) cmd.ray(pixels, pixels) cmd.png(output+"_3", dpi=300) cmd.turn('y',90) cmd.ray(pixels, pixels) cmd.png(output+"_4", dpi=300) cmd.turn('y',90) cmd.set('surface_quality',0) # make front and back figures for single mode elif mode == 'stereo': cmd.set('surface_quality',1) cmd.set('ray_shadow',0) cmd.ray(750, 750, angle=-3) cmd.png(output+"_R", dpi=300) cmd.ray(750, 750, angle=3) cmd.png(output+"_L", dpi=300)
with open(edgepath,'r') as fin : data = fin.readlines(); edges = [line.strip().split() for line in data] for n,e in enumerate(edges) : t = cmd.dist('dist'+str(n),'3H4E//A/'+e[0]+'/CA',\ '3H4E//A/'+e[1]+'/CA') if t < cutoff : cmd.delete('dist'+str(n)) else : cmd.color('blue','dist'+str(n)) cmd.hide('labels','dist'+str(n)) cmd.show('spheres','3H4E//A/'+e[0]+'/CA') cmd.show('spheres','3H4E//A/'+e[1]+'/CA') cmd.color('yellow','3H4E//A/'+e[0]+'/CA') cmd.color('yellow','3H4E//A/'+e[1]+'/CA') cmd.set('dash_radius','0.2'); cmd.set('dash_gap','0.0'); cmd.set('sphere_scale','0.3') #cmd.set('sphere_scale','0.8','retinal'); cmd.ray() print('*'*5+'Image:%s'%os.path.abspath(outfp)+'*'*5) cmd.png(os.path.abspath(outfp)) print '-------Completed Call--------';
cmd.color('_colorm', 'sm') #cmd.set ('label_font_id', 16) #cmd.set ('label_size', 24) #cmd.pseudoatom('xatom', pos=[1,0,0], label="x") #cmd.pseudoatom('yatom', pos=[0,1,0], label="y") #cmd.pseudoatom('zatom', pos=[0,0,2], label="z") cmd.set('label_font_id', 16) cmd.set('label_size', 20) cmd.pseudoatom('xatom', pos=[2.5, 0, 0], label="x") cmd.pseudoatom('yatom', pos=[0, 2.5, 0], label="y") cmd.pseudoatom('zatom', pos=[0, 0, 5.5], label="z") cmd.set('ray_opaque_background', 'on') cmd.set('transparency', 0.50) cmd.set_view('\ -0.086753346, 0.836276770, 0.541441798,\ 0.670052588, -0.353231400, 0.652936995,\ 0.737265468, 0.419426382, -0.529700875,\ 0.000000000, 0.000000000, -34.167503357,\ 0.108778238, 0.131587982, 2.662951946,\ 26.937919617, 41.397087097, -20.000000000') cmd.pseudoatom('latom', pos=[3.5, -2.5, 0], label="_label") cmd.ray(1024, 1024) cmd.png('this.png', dpi=600) cmd.quit()
def FocalBlur(aperture=2.0, samples=10, ray=0, width=0, height=0): ''' DESCRIPTION Creates fancy figures by introducing a focal blur to the image. The object at the origin will be in focus. AUTHOR Jarl Underhaug University of Bergen jarl_dot_underhaug_at_gmail_dot_com Updates by Jason Vertrees and Thomas Holder USAGE FocalBlur aperture=float, samples=int, ray=0/1, width=int, height=int EXAMPELS FocalBlur aperture=1, samples=100 FocalBlur aperture=2, samples=100, ray=1, width=600, height=400 ''' # Formalize the parameter types ray = (ray in ("True", "true", 1, "1")) aperture, samples = float(aperture), int(samples) width, height = int(width), int(height) # Create a temporary directory tmpdir = mkdtemp() # Get the orientation of the protein and the light light = cmd.get('light')[1:-1] light = [float(s) for s in light.split(',')] view = cmd.get_view() # Rotate the protein and the light in order to create the blur for frame in range(samples): # Angles to rotate protein and light # Populate angles as Fermat's spiral theta = frame * pi * 110.0 / 144.0 radius = 0.5 * aperture * sqrt(frame / float(samples - 1)) x = cos(theta) * radius y = sin(theta) * radius xr = x / 180.0 * pi yr = y / 180.0 * pi # Rotate the protein cmd.turn('x', x) cmd.turn('y', y) # Rotate the light ly = light[1] * cos(xr) - light[2] * sin(xr) lz = light[2] * cos(xr) + light[1] * sin(xr) lx = light[0] * cos(yr) + lz * sin(yr) lz = lz * cos(yr) - lx * sin(yr) cmd.set('light', [lx, ly, lz]) curFile = "%s/frame-%04d.png" % (tmpdir, frame) print("Created frame %i/%i (%0.0f%%)" % (frame + 1, samples, 100 * (frame + 1) / samples)) # Save the image to temporary directory if ray: cmd.ray(width, height) cmd.png(curFile) else: cmd.png(curFile, quiet=1) # Create the average/blured image try: avg = Image.blend(avg, Image.open(curFile), 1.0 / (frame + 1)) except: avg = Image.open(curFile) # Return the protein and the light to the original orientation cmd.set('light', light) cmd.set_view(view) # Load the blured image avg.save('%s/avg.png' % (tmpdir)) cmd.load('%s/avg.png' % (tmpdir)) # Delete the temporary files rmtree(tmpdir)
cmd.pseudoatom('yatom', pos=[0, 2.5, 0], label="y") cmd.pseudoatom('zatom', pos=[0, 0, 4.0], label="z") cmd.set('ray_opaque_background', 'off') cmd.set('transparency', 0.30) #cmd.set_view ('\ # -0.086753346, 0.836276770, 0.541441798,\ # 0.670052588, -0.353231400, 0.652936995,\ # 0.737265468, 0.419426382, -0.529700875,\ # 0.000000000, 0.000000000, -34.167503357,\ # 0.108778238, 0.131587982, 1.662951946,\ # 26.937919617, 41.397087097, -20.000000000' ) # cmd.set_view('\ -0.036295272, 0.997309446, 0.063655443,\ -0.180431277, -0.069193237, 0.981151760,\ 0.982915938, 0.024127077, 0.182457983,\ 0.000000000, 0.000000000, -42.977798462,\ 0.235994816, 0.235994816, 0.235994816,\ 33.884025574, 52.071571350, -20.000000000') #cmd.pseudoatom('latom', pos=[3.5,-2.5,0], label="_label") #cmd.pseudoatom('latom', pos=[-3,0,0], label=u"\u0394\u03C1'\u2081".encode('utf-8')) cmd.pseudoatom('latom', pos=[-3, 0, 0], label=u"_label".encode('utf-8')) cmd.ray(1200, 1200) cmd.png('this.png', dpi=600) cmd.quit()
lines = f.readlines()[1:] for line in lines: line_elements = line.strip().split(',') site = int(line_elements[0]) neff = float(line_elements[-1]) neffs[site] = neff # Determine the min and max entropy to set the range of the color scale min_neff = min(neffs.values()) max_neff = max(neffs.values()) # Change each residue's B factor to its entropy value for site in neffs: cmd.alter("resi %d" % site, "b = %g" % neffs[site]) # Color the structure by B-factor values cmd.spectrum('b', 'yellow_red', structure, minimum=min_neff, maximum=max_neff) # set up view cmd.set_view('-0.722045004, -0.058464222, -0.689368665, ' '0.598552346, 0.446926057, -0.664827526, ' '0.346962959, -0.892658830, -0.287708551, ' '0.000000000, 0.000000000, -119.305297852, ' '16.283113480, 28.784046173, 25.007221222, ' '91.323577881, 147.287002563, -20.000000000') cmd.select('none') cmd.ray(1600, 1200) cmd.png('./results/prefs/structure_by_neff.png')
""" A script that will execute a 360 degree spin of the structure, ray-tracing the structure at each interval and saving the image. """ from pymol import cmd import os.path FRAMES = 360 # How many frames to spread the spin over AXIS = 'y' # The axis about which to spin OUTPUT = 'turn_ray_images' # The output directory for images RAY_X = 1920 # The x-dimension of the image, 0 will use current window size RAY_Y = 1080 # The y-dimension of the image, 0 will use current window size os.mkdir(OUTPUT) for i in xrange(FRAMES): cmd.turn(AXIS, 360.0 / FRAMES) cmd.ray(width=RAY_X, height=RAY_Y) frame_name = '{0}.png'.format(str(i).zfill(4)) cmd.png(os.path.join(os.getcwd(), OUTPUT, frame_name))
def compare_10gs_11gs(): # it is possible to download proteins from RCSB (Protein Data Bank) to fetch_path, which is current working # directory by default cmd.set('fetch_path', cmd.exp_path(PATH_data)) cmd.fetch('10gs') cmd.fetch('11gs') cmd.load('{0}10gs.cif'.format(PATH_data), '10gs') cmd.load('{0}11gs.cif'.format(PATH_data), '11gs') # proteins # pymol has several options for proteins alignment, align is better for proteins with high homology align_command = cmd.align # or super, or cealign align_res = align_command('10gs', '11gs') if align_command == cmd.align: print('aligned with rmsd {0}'.format(align_res[0])) # cmd.create creates a separate object (copies everything to it) # het stands for heteroatoms (non-protein) cmd.create('10gs_protein', '10gs and not het') cmd.create('11gs_protein', '11gs and not het') # print protein sequences for fun fasta_10gs = cmd.get_fastastr(selection='10gs_protein') fasta_11gs = cmd.get_fastastr(selection='11gs_protein') print('10gs sequence:{0}'.format(fasta_10gs)) print('11gs sequence:{0}'.format(fasta_11gs)) cmd.delete('*_protein') # delete objects # ligands cmd.select('10gs_ligands', '10gs and not resname HOH and het') cmd.select('11gs_ligands', '11gs and not resname HOH and het') space_10gs = {'lig_names': []} # or simpy lig_names = [] space_11gs = {'lig_names': []} # strange pymol interface to iterate over atoms cmd.iterate('10gs_ligands', 'lig_names.append(resn)', space=space_10gs) cmd.iterate('11gs_ligands', 'lig_names.append(resn)', space=space_11gs) ligs_10gs = set(space_10gs['lig_names']) ligs_11gs = set(space_11gs['lig_names']) # by the way, in both 10gs and 11gs we have MSE, which is actually a modified residue and not a ligand print('ligands found in 10gs: {0}'.format(ligs_10gs)) print('ligands found in 11gs: {0}'.format(ligs_11gs)) for ligand_unique in ligs_10gs.symmetric_difference(ligs_11gs): cmd.save( '{0}{1}_{2}_ligand.sdf'.format( PATH_data, '10gs' if ligand_unique in ligs_10gs else '11gs', ligand_unique), 'resname {0}'.format(ligand_unique)) # deleting selection, objects remain unchanged cmd.delete('ligs*') print('drawing a figure (this will take some time)') cmd.set('transparency_mode', 1) cmd.bg_color('white') cmd.show('sticks', 'het and not resname HOH') cmd.color('white', 'not het') cmd.show('surface', 'not het') cmd.hide('lines') cmd.set('transparency', '0.7') cmd.show('spheres', 'resname HOH') cmd.color('palecyan', 'resname HOH') cmd.hide('nonbonded', 'resname HOH') cmd.set('sphere_transparency', '0.7') cmd.ray() cmd.png('{0}fig.png'.format(PATH_data))
cutoff = 2 # Load the edges from file with open(edgepath, 'r') as fin: data = fin.readlines() edges = [line.strip().split() for line in data] for n, e in enumerate(edges): t = cmd.dist('dist'+str(n),'3H4E//A/'+e[0]+'/CA',\ '3H4E//A/'+e[1]+'/CA') if t < cutoff: cmd.delete('dist' + str(n)) else: cmd.color('blue', 'dist' + str(n)) cmd.hide('labels', 'dist' + str(n)) cmd.show('spheres', '3H4E//A/' + e[0] + '/CA') cmd.show('spheres', '3H4E//A/' + e[1] + '/CA') cmd.color('yellow', '3H4E//A/' + e[0] + '/CA') cmd.color('yellow', '3H4E//A/' + e[1] + '/CA') cmd.set('dash_radius', '0.2') cmd.set('dash_gap', '0.0') cmd.set('sphere_scale', '0.3') #cmd.set('sphere_scale','0.8','retinal'); cmd.ray() print('*' * 5 + 'Image:%s' % os.path.abspath(outfp) + '*' * 5) cmd.png(os.path.abspath(outfp)) print '-------Completed Call--------'
def cheese(render_type, savefile=None, duration=5, mode='ray', width=1920, height=1080): """ DESCRIPTION loads nice settings for rendering and take a picture or records a movie of the trajectory. Before running, position the camera to have a good point of view. USAGE cheese render_type [, savefile [, duration [, mode [, width [, height]]]]] ARGUMENTS render_type = one of: - set: only load render settings - snap: take a snapshot of the current view - traj: record the whole trajectory - bullettime: make a whole revolution around the z axis savefile = file name to use to save the movie, without extension. If not given, the movie won't be save but only shown (default=None) duration = duration in seconds of the final movie (default=5) mode = set to 'draw' to disable ray tracing (default='ray') width = width of the movie in pixel (default=1920) height = height of the movie in pixel (default=1080) """ duration = int(duration) # # store settings for later restoration # store_settings.load() # cmd.sync() # settings_file = '/tmp/stir_settings.py' # cmd.do(f'store_settings {settings_file}') # load nice settings for rendering config.rendering() cmd.sync() def init_movie(): cmd.mdelete() cmd.mview('reset') frames = duration * 30 cmd.mset(f'1x{frames}') return frames # only load settings if render_type == 'set': return # take a simple picture elif render_type == 'snap': cmd.ray(width=width, height=height) # make a still movie of the whole trajectory elif render_type == 'traj': frames = init_movie() cmd.mview('store', 1, state=1) cmd.sync() states = cmd.count_states() cmd.mview('store', frames, state=states) cmd.sync() cmd.mview('reinterpolate') cmd.sync() # make a movie rotating 360 around the z axis elif render_type == 'bullettime': frames = init_movie() cmd.mview('store', 1) cmd.mview('store', frames) # TODO: moving objects seems a bit hacky. Any better solution? for obj in cmd.get_object_list(): cmd.mview('store', object=obj) cmd.sync() for i in range(4): frame = int(frames * (i + 1) / 4) cmd.frame(frame) cmd.sync() for obj in cmd.get_object_list(): cmd.rotate('z', angle=-90, camera=0, object=obj) cmd.sync() cmd.mview('store', object=obj) cmd.sync() cmd.mview('reinterpolate', object=obj, power=1) cmd.sync() cmd.mview('reinterpolate') cmd.sync() else: raise ValueError( f'{render_type} is not a valid argument. See `help cheese`.') # save if required, otherwise just play it if savefile: if render_type in ( 'traj', 'bullettime', ): cmd.viewport(width, height) movie.produce(f'{savefile}.mp4', mode=mode, encoder='ffmpeg', quality=100) elif render_type in ('snap', ): cmd.png(f'{savefile}.png', dpi=300) cmd.sync() else: if render_type in ( 'traj', 'bullettime', ): cmd.mplay() elif render_type in ('snap', ): pass
def save_image_default(filename): cmd.bg_color("white") cmd.ray(default_image_size(), default_image_size()) cmd.png("./output/" + filename + ".png", dpi=dpi()) cmd.bg_color("black") return
values = inFile.readlines() print values # create the global, stored array stored = [] # read the new B factors from file for line in values: stored.append( float(line) ) print stored max_b = max(stored) min_b = min(stored) cmd.bg_color("white") print min_b print max_b # close the input file inFile.close() # clear out the old B Factors cmd.alter("%s and n. CA"%pdb, "b=0.0") # update the B Factors with new properties cmd.alter("%s and n. CA"%pdb, "b=stored.pop(0)") # color the protein based on the new B Factors of the alpha carbons cmd.spectrum("b", "rainbow", "%s and n. CA"%pdb, minimum=min_b, maximum=max_b) cmd.ray("775", "2400") cmd.png("unscaled%s.png"%infilename.split("_")[0])
A = AggregatTransferFromFile(fname) cmd.set_view ([ -0.480811268, 0.603387773, 0.636203885, 0.675508440, 0.717507422, -0.169974893, -0.559037924, 0.348030269, -0.752567112, -0.000127681, 0.000030167, -122.974456787, 13.921709061, -7.469791889, -4.264435768, -1086.176879883, 1332.132446289, -20.000000000]) # select only a few sample points indices = [0, 250, 500, 1000, 1999] t = np.linspace(0, A._tLength, A._tSteps)[indices] # Get values ordered by time in first index values = np.swapaxes(A.get(), 0, 1)[indices] selections = ['lab{}'.format(i + 1) for i in range(8)] for lab in selections: cmd.label(lab, '') selections = ['bcl{}'.format(i + 1) for i in range(7)] for i, val in enumerate(values): alpha = p_to_alpha(val) for n, bcl in enumerate(selections): cmd.set_bond('stick_transparency', alpha[n], bcl) cmd.refresh() cmd.ray(width, height) print('Belongs to time {}'.format(t[i] * 5.20883746)) cmd.png('../fmo_transfer_{}.png'.format(i), dpi=DPI, ray=1)
def save_image_filament(filename): cmd.bg_color("white") cmd.ray(ray_width_filament(), ray_height_filament()) cmd.png("./output/" + filename + ".png", dpi=dpi()) cmd.bg_color("black") return
def setray0(): cmd.set("ray_trace_mode", "0") cmd.ray()
def setray2(): cmd.set("ray_trace_mode", "2") cmd.bg_color('white') cmd.ray()
def setray3(): cmd.set("ray_trace_mode", "3") cmd.ray()
for i in range(5): cmd.load("./PDBs-%d/State%d-%d.pdb" % (p_id, stateid, i)) for i in range(5): cmd.align("State%d-%d" % (stateid, i), "State%d-%d" % (stateid, ref_state_id)) #alignto does the same thing as the above loop, but it sometimes could cause problem #cmd.alignto("State%d-0"%stateid) cmd.show("cartoon") cmd.hide("lines", "!State%d-%d" % (stateid, ref_state_id)) cmd.center("all") cmd.set("cartoon_transparency", 0.7, "all") cmd.set("cartoon_transparency", 0, "State%d-%d" % (stateid, ref_state_id)) cmd.util.chainbow("all") cmd.util.cnc("all") cmd.orient() cmd.util.performance(0) cmd.set("ray_opaque_background", "off") cmd.ray() png_fn = os.path.join(outdir, "image-p%d-state-%d.png" % (p_id, stateid)) high_res_state = [0, 1, 2, 4, 11, 12, 13, 20, 28, 30] if stateid in high_res_state: png_fn = os.path.join(outdir, "image-p%d-state-%d-highres.png" % (p_id, stateid)) cmd.ray(2400, 1800) cmd.png(png_fn, dpi=300) else: cmd.png(png_fn) cmd.quit()
def pubimage_tmblr(*argumenthere, **kwd): '''Takes an image with the specified properties. The properties should be entered in the following order: ray_trace_mode, antialias, ray width, ray height, bg_color If not specified, then the properties default to ray_trace_mode (int 1-3) --> 3 antialias (int 0-2) --> 2 raynum1, raynum2 (int) --> ray 1200, 1200 bg_color (string) --> white ''' # The following is for debugging: # argumenthere[0] (int 1-3) --> ray_trace_mode (int) # argumenthere[1] (int 0-2) --> antialias (int) # argumenthere[2], argumenthere[3] (int) --> ray num1, num2 (int) # argumenthere[4] (string) --> bg_color (string) global iternum #Setting ray_trace_mode try: cmd.set('ray_trace_mode', value=int(argumenthere[0]), selection='', state=0, updates=1, log=0, quiet=1) except IndexError: cmd.set('ray_trace_mode', 3) #Setting antialias try: cmd.set('antialias', int(argumenthere[1]), selection='', state=0, updates=1, log=0, quiet=1) except IndexError: cmd.set('antialias', 2) #Setting bg_color try: cmd.bg_color(argumenthere[4]) except IndexError: cmd.bg_color('white') #CENTER IMAGE TAKING AND ROTATION #Ray the image try: cmd.ray(width=int(argumenthere[2]), height=int(argumenthere[3]), antialias=-1, angle=0.0, shift=0.0, renderer=-1, quiet=1, async=0) except IndexError: cmd.ray(width=1200, height=1200) #Save the Image try: cmd.png('molecule' + str(iternum) + 'center.png') except IndexError: cmd.png('molecule' + str(iternum) + 'center.png') cmd.turn('x', 90.0) #TOP-DOWN IMAGE TAKING AND ROTATION #Ray the image try: cmd.ray(width=int(argumenthere[2]), height=int(argumenthere[3]), antialias=-1, angle=0.0, shift=0.0, renderer=-1, quiet=1, async=0) except IndexError: cmd.ray(width=1200, height=1200) #Save the Image try: cmd.png('molecule' + str(iternum) + 'topdown.png') except IndexError: cmd.png('molecule' + str(iternum) + 'topdown.png') cmd.turn('x', -180.0) #BOTTOM-UP IMAGE TAKING AND ROTATION #Ray the image try: cmd.ray(width=int(argumenthere[2]), height=int(argumenthere[3]), antialias=-1, angle=0.0, shift=0.0, renderer=-1, quiet=1, async=0) except IndexError: cmd.ray(width=1200, height=1200) #Save the Image try: cmd.png('molecule' + str(iternum) + 'bottomup.png') except IndexError: cmd.png('molecule' + str(iternum) + 'bottomup.png') cmd.turn('x', 90.0) cmd.turn('y', 90.0) #LEFT IMAGE TAKING AND ROTATION #Ray the image try: cmd.ray(width=int(argumenthere[2]), height=int(argumenthere[3]), antialias=-1, angle=0.0, shift=0.0, renderer=-1, quiet=1, async=0) except IndexError: cmd.ray(width=1200, height=1200) #Save the Image try: cmd.png('molecule' + str(iternum) + 'left.png') except IndexError: cmd.png('molecule' + str(iternum) + 'left.png') cmd.turn('y', -180.0) #RIGHT IMAGE TAKING AND ROTATION #Ray the image try: cmd.ray(width=int(argumenthere[2]), height=int(argumenthere[3]), antialias=-1, angle=0.0, shift=0.0, renderer=-1, quiet=1, async=0) except IndexError: cmd.ray(width=1200, height=1200) #Save the Image try: cmd.png('molecule' + str(iternum) + 'right.png') except IndexError: cmd.png('molecule' + str(iternum) + 'right.png') cmd.turn('y', 90.0) iternum += 1