def images_spin(images, sweep, axis):
global imagecount
global ray
global filename
global ximage
global yimage
print "... Images %s - %s:" % (imagecount, imagecount + images - 1)
print "Writing %s images turning about %s axis by %s degrees per image" % \
(images, axis, sweep/images)
#cycle over images
for i in range(0, images):
#move camera
cmd.turn(axis, sweep /
images) # turn each image the fraction of the total spin
#print image
cmd.png("images/%s_%04d" % (filename, imagecount), ray=ray)
#increment imagecounter
print "cycle %s, image %s" % (i + 1, imagecount)
imagecount = imagecount + 1
cmd.refresh()
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 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 images_spin3_slide3(images, distance, sweep):
global imagecount
global ray
global filename
global ximage
global yimage
print "... Images %s - %s:" % (imagecount, imagecount + images - 1)
print "Writing %s images turning about:" % images
print " x axis by %s degrees, then" % (sweep[0] / images)
print " y axis by %s degrees, and" % (sweep[1] / images)
print " z axis by %s degrees per image," % (sweep[2] / images)
print " while moving along:"
print " x axis by %s Angstrom," % (distance[0] / images)
print " y axis by %s Angstrom, and" % (distance[1] / images)
print " z axis by %s Angstrom per image" % (distance[2] / images)
for i in range(0, images): #cycle for number of images
# transformations
cmd.turn("x", sweep[0] / images)
cmd.turn("y", sweep[1] / images)
cmd.turn("z", sweep[2] / images)
cmd.move("x", distance[0] / images)
cmd.move("y", distance[1] / images)
cmd.move("z", distance[2] / images)
#print image
cmd.png("images/%s_%04d" % (filename, imagecount), ray=ray)
#increment imagecounter
imagecount = imagecount + 1
cmd.refresh()
def images_screw(images, distance, sweep, axis):
global imagecount
global ray
global filename
global ximage
global yimage
print "... Images %s - %s:" % (imagecount, imagecount + images - 1)
print "Writing %s images moving along %s axis by %s Angstrom" % \
(images, axis, distance/images)
print " and rotating %s degrees per image" % (sweep / images)
for i in range(0, images): #cycle for number of images
# transformations
cmd.move(axis, distance / images)
cmd.turn(axis, sweep / images)
#print image
cmd.png("images/%s_%04d" % (filename, imagecount), ray=ray)
#increment imagecounter
imagecount = imagecount + 1
cmd.refresh()
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 show_motif(interaction, domain1, domain2, residues1, residues2):
cmd.load("PDBFiles/%s.pdb" % domain1)
cmd.load("PDBFiles/%s.pdb" % domain2)
cmd.bg_color("white")
cmd.hide("all")
cmd.show("cartoon", "all")
cmd.select("motif1", "none")
cmd.select("motif1",
"motif1 or (%s and n. CA and resi %s)" % (domain1, residues1))
cmd.select("motif2", "none")
cmd.select("motif2",
"motif2 or (%s and n. CA and resi %s)" % (domain2, residues2))
cmd.select("none")
cmd.color("gray80", domain1)
cmd.color("gray60", domain2)
cmd.color("cyan", "motif1")
cmd.color("magenta", "motif2")
try:
cmd.pair_fit("motif1", "motif2")
cmd.center(domain1)
cmd.png("PNGs/%s_%s_%s_PF.png" % (interaction, domain1, domain2),
dpi=300)
except CmdException:
pass
try:
cmd.cealign("motif1", "motif2")
cmd.center(domain1)
cmd.png("PNGs/%s_%s_%s_CE.png" % (interaction, domain1, domain2),
dpi=300)
except CmdException:
pass
def png(self, filename, *args, **kwargs):
'''
Save image to filename, with antialias=0.
'''
cmd.unset('antialias')
cmd.png(filename, *args, **kwargs)
cmd.draw()
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 paper_png(filename, width=100, height=0, dpi=300, ray=1):
"""
DESCRIPTION
Saves a PNG format image file of the current display.
Instead of pixel dimensions, physical dimensions for
printing (in millimeters) and DPI are specified.
USAGE
paper_png filename [, width [, height [, dpi [, ray ]]]]
ARGUMENTS
filename = string: filename
width = float: width in millimeters {default: 100 = 10cm}
width = string: width including unit (like: '10cm' or '100mm')
height = float or string, like "width" argument. If height=0, keep
aspect ratio {default: 0}
dpi = float: dots-per-inch {default: 300}
ray = 0 or 1: should ray be run first {default: 1 (yes)}
SEE ALSO
png
"""
dpi, ray = float(dpi), int(ray)
width = unittouu(width, dpi)
height = unittouu(height, dpi)
cmd.png(filename, width, height, dpi, ray)
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 export_objects_to_png():
objects = cmd.get_object_list('all')
cmd.disable('all')
for pobj in objects:
cmd.enable(pobj)
cmd.png('{}.png'.format(pobj), width=2340, height=1239, ray=1)
cmd.disable(pobj)
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 snapshotPymolShape(self, inputName, idList, rot, tran, extension=None):
if extension is not None:
# Temporarily extend shape
lastNodeName = idList[-1]
lastNodeName = lastNodeName[:lastNodeName.rfind('#')]
idList,extRot,extTran,extName = \
self.growShape(lastNodeName,
idList,
extension)
self.transformPymolShape(idList, tran, rot, [0, 0, 0])
for single in idList:
cmd.show('cartoon', single)
self.alignPymolView()
cmd.png(elfinMovieDir + inputName + '/frame' + str(self.frameCount))
self.frameCount += 1
# Restore shape so next transform will be correct
self.transformPymolShape(idList, [0, 0, 0], np.linalg.inv(rot),
-1 * np.asarray(tran))
for single in idList:
cmd.hide('cartoon', single)
if extension is not None:
# Restore temporary extension
idList = idList[:-1]
cmd.delete(extName)
self.transformPymolShape(idList, -1 * np.asarray(extTran),
np.linalg.inv(extRot), [0, 0, 0])
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 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 png(self, filename, *args, **kwargs):
'''
Save image to filename, with antialias=0.
'''
cmd.set('antialias', 0)
cmd.png(filename, *args, **kwargs)
cmd.draw()
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 images_spin_3ax(images, sweep):
global imagecount
global ray
global filename
global ximage
global yimage
print "... Images %s - %s:" % (imagecount, imagecount + images - 1)
print "Writing %s images turning about:" % images
print " x axis by %s degrees," % (sweep[0] / images)
print " y axis by %s degrees, and" % (sweep[1] / images)
print " z axis by %s degrees per image" % (sweep[2] / images)
#cycle over number of images
for i in range(0, images):
# transformations
cmd.turn("x", sweep[0] / images)
cmd.turn("y", sweep[1] / images)
cmd.turn("z", sweep[2] / images)
#print image
cmd.png("images/%s_%04d" % (filename, imagecount), ray=ray)
#increment imagecounter
imagecount = imagecount + 1
cmd.refresh()
def paper_png(filename, width=100, height=0, dpi=300, ray=1):
'''
DESCRIPTION
Saves a PNG format image file of the current display.
Instead of pixel dimensions, physical dimensions for
printing (in millimeters) and DPI are specified.
USAGE
paper_png filename [, width [, height [, dpi [, ray ]]]]
ARGUMENTS
filename = string: filename
width = float: width in millimeters {default: 100 = 10cm}
width = string: width including unit (like: '10cm' or '100mm')
height = float or string, like "width" argument. If height=0, keep
aspect ratio {default: 0}
dpi = float: dots-per-inch {default: 300}
ray = 0 or 1: should ray be run first {default: 1 (yes)}
SEE ALSO
png
'''
dpi, ray = float(dpi), int(ray)
width = unittouu(width, dpi)
height = unittouu(height, dpi)
cmd.png(filename, width, height, dpi, ray)
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 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 morph_movie(morph,
view,
color,
base_name,
frameno_offset=0,
morph_reverse=False):
number_of_states = cmd.count_states(morph)
# after this I will have each state available as its own object, called "{morphname}_000x" (padded to length of 4)
# x starts with 1 --> not clear - that might depend on the numbering in the input file
cmd.split_states(morph)
last_frame = frameno_offset
for statenum in range(0, number_of_states + 1):
if morph_reverse:
statenum = max(1, cmd.count_states(morph) - statenum)
else:
statenum = min(statenum + 1, cmd.count_states(morph))
state_name = morph + "_" + str(statenum).zfill(4)
clump_representation([state_name], color, state_name),
cmd.set_view(view)
cmd.png(base_name + str(last_frame).zfill(3),
width=1920,
height=1080,
ray=True)
clump_cleanup([state_name], state_name)
cmd.remove(state_name)
last_frame += 1
return last_frame
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 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 photo_pdb(pdb_file, out_file):
pymol.finish_launching(['pymol', '-qc'])
cmd.reinitialize()
cmd.load(pdb_file)
cmd.show_as('cartoon', 'all')
cmd.util.cbc()
cmd.png(filename=out_file, width=350, height=350, ray=0, dpi=300)
cmd.quit()
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 colour_by_heatmap(colour_data,
structure_path,
molecule_name="protein",
output_path="colour_by_heatmap",
view=None):
'''
DESCRIPTION
Colours PDB structure by colour map data.
output_filepath
>>> colour_by_heatmap(df, structure_filepath="xxxx.pdb", mol_name="protein", out_dir='.')
'''
# if not (isinstance(colour_data, pd.core.series.Series) or isinstance(colour_data, dict)):
# print('''
# Passed data must be either dictionary or Pandas Series object.
# Key = residue number
# Value = PyMOL hex code
# ''')
# return None
cmd.load(structure_path, object=molecule_name)
# Set view
if view == None:
cmd.reset()
cmd.orient()
else:
cmd.set_view(view)
cmd.viewport(width=1200, height=1200)
cmd.zoom(complete=1)
cmd.set('cartoon_discrete_colors', 1)
cmd.set('sphere_scale', 1)
cmd.show_as('cartoon', molecule_name)
cmd.color('white', molecule_name)
# Iterate over the alpha-carbons
# residue_numbers = []
# cmd.iterate('{} and name CA'.format(molecule_name) , 'residue_numbers.append(resi)')
# Colour the structure
for residue_number in colour_data.columns:
# print(colour_data[residue_number].item())
cmd.color(colour_data[residue_number].item(),
'{0} and resi {1}'.format(molecule_name, residue_number))
png_out_path = output_path + ".png"
pse_out_path = output_path + ".pse"
cmd.save(pse_out_path)
cmd.set('ray_opaque_background', 0)
cmd.png(png_out_path, width=1200, height=1200, ray=1, quiet=0)
def save_dens(fname, isovals="-0.02 0.02", colors="cyan orange", delete=True):
"""
Plot and save the density (same options as show_dens).
"""
dname = show_dens(fname, isovals, colors)
pname = dname + ".png"
cmd.png(pname, ray=1)
print("Image saved as %s." % pname)
if delete:
cmd.delete(dname + "*")
def screenshotProteins():
# proteinsPath = ".\pdbs"
# set style parameters
# cmd.set("ray_opaque_background", 0)
# cmd.remove("solvent")
cmd.set("ambient", 0.3)
cmd.set("antialias", 1)
cmd.bg_color("white")
# cmd.set("direct", 1.0)
# cmd.set("ribbon_radius", 0.2)
# cmd.set("cartoon_highlight_color", "grey50")
# cmd.set("ray_trace_mode", 1)
# cmd.set("stick_radius", 0.2)
# cmd.set("mesh_radius", 0.02)
# loop thru folders
# for dir in os.walk(proteinsPath):
# proteinPath = dir[0]
# loop thru pdbs
# for file in os.listdir(proteinPath):
# if file.endswith('.pdb'):
csvFileName = "docked-protein-homomers.csv"
# to loop through csv
file = open(csvFileName, "r")
reader = csv.reader(file, delimiter=",")
k = 1
for row in reader:
for item in row:
print(k, item)
cmd.reinitialize()
# load the pdb file
cmd.fetch(item, path="./pdbs", type='pdb')
#pdbPath= "./pdbs/" + item + ".cif"
#cmd.load(pdbPath)
color = pickAColor()
cmd.color(color)
cmd.show("cartoon")
cmd.remove("solvent")
# take a screenshot
screenshotFileName = item + ".png"
screenshotPath = os.path.join('screenshots', screenshotFileName)
cmd.png(screenshotPath, 128, 128, ray=1)
# clear
cmd.delete("all")
k = k + 1
def ross_pic(molecule):
'''
for Jennifer Ross picture.
'''
# if pic != 0:
cmd.png(molecule,
width=4800,
height=3600,
dpi=1200, # currently creates 1.2 Mb.
ray=0, # shadowing if 1,2
quiet=0)
def testPngExists(self):
'''
Save a PNG image with width/height specified and
check if the file exists.
'''
cmd.pseudoatom('m1')
cmd.show('spheres')
with testing.mktemp('.png') as filename:
cmd.png(filename, width=100, height=100, ray=0)
cmd.draw()
self.assertTrue(os.path.exists(filename), 'png file not written')
def ray_tracer(width, height, scenes="all", ray=1, directory=""):
"""
ray_tracer will call png for scenes in a pymol session. All these scenes will be
produced with the same dimensions. By default, all scenes are generated with ray
tracing turned on in the current directory. Files will be named the same as their
scene names.
width, height = The width and height in pixels of the resulting images.
scenes = A scene or pythonic list of scenes to raytrace (e.g. "scene1" or ["scene1", "scene2"]). By default, do all scenes.
raytrace = Should we raytrace? Passed on to ray in png command.
directory = By default, images will be saved in the current directory. A relative path can be given
here for a different directory to be used.
"""
#Check if 'all' happens to be a scene name. If so, print an error message and quit.
assert (
"all" not in cmd.get_scene_list()
), "You have 'all' as a scene name. This causes a conflict with ray_tracer. Change the scene name."
#The directory name must end in a forward / (unless it is an empty string). If it doesn't, add one for the user
if (directory != "" and directory[-1:] != "/"): directory = directory + "/"
#Figure out which scenes to png
#if scenes == all, get all scenes and use that as our list.
if (scenes == 'all'):
scene_list = cmd.get_scene_list()
#if scenes is a list object, use that as our list.
elif (isinstance(scenes, list)):
scene_list = scenes
#Otherwise, assume we have a string that corresponds to a scene name
else:
scene_list = [scenes]
#Make sure that the scene_animation setting is set to 0, or changing view will not work.
cmd.set("scene_animation", 0)
#scene_list should now have a list of all the scenes to render.
#Loop over scene_list and cmd.png each one.
for scene in scene_list:
#Check that the scene actually exists, or spit out an error.
if (scene not in cmd.get_scene_list()):
print("The scene " + scene +
" is not a scene in your pymol environment. Skipping.")
continue
#Change to the appropriate scene.
cmd.scene(scene)
cmd.sync()
#Figure out the full name of the output file.
imgname = directory + scene + ".png"
#Actually make the image.
cmd.png(filename=imgname, width=width, height=height, ray=ray)
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 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 render_false_color_image(width, height, filename=''):
global tmpdir
tmpFile = get_temporary_file(filename)
# draw with antialiasing disabled
cmd.draw(width, height, 0)
cmd.png(tmpFile)
while not os.path.exists(tmpFile):
time.sleep(1)
if DEBUG:
print "created temporary file %s" % tmpFile
return tmpFile
def test(self):
cmd.set('opaque_background')
with testing.mktemp('tmp.pse') as session_filename:
with testing.mktemp('bg.png') as bg_image_filename:
cmd.bg_color('red')
cmd.png(bg_image_filename)
cmd.bg_color('blue')
cmd.set('bg_image_filename', bg_image_filename)
cmd.save(session_filename)
cmd.load(session_filename)
x = cmd.get('bg_image_filename')
self.assertTrue(x.startswith('data:'))
self.assertImageHasColor('red', delta=4,
msg='bg_image_filename=data: not rendered')
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 save_image(spath, name_maxlength, prefix = ''):
fname = os.path.splitext(os.path.basename(spath))[0]
image_name = prefix + image_filename(fname, name_maxlength)
if exists(image_name):
print 'Skip: ' + fname
else:
print 'Process: ' + fname
cmd.load(spath, fname)
cmd.disable('all')
cmd.enable(fname)
cmd.color('green', fname)
cmd.h_add('(all)')
cmd.show('surface')
cmd.rotate([-1, 0.5, 0.5], 60)
cmd.zoom(fname, -7.0, 0, 1)
cmd.png(image_name)
time.sleep(3) # wtf?!
cmd.delete('all')
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=""):
"""
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 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)
"""
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 _pngExistsAsync(self, filename, sync_in_thread):
cmd.png(filename, width=100, height=100, ray=0)
cmd.draw()
if sync_in_thread:
cmd.sync()
def produce_frame():
name = '/tmp/frame.png'
cmd.png(name, ray=True, width=1920, height=1080)
with open(name, 'rb') as frame:
os.write(produce_frame.pipe, frame.read())
os.remove(name)
import threading
def dump_thread():
print
for thr in threading.enumerate():
print(thr)
dump_thread()
import pymol
pymol.pymol_launch=4
pymol.pymol_argv = [ 'pymol', '-qc'] # Quiet / no GUI
from pymol import cmd
pymol.finish_launching()
dump_thread()
cmd.fetch('1TUP', async=False)
cmd.disable('all')
cmd.enable('1TUP')
cmd.bg_color('white')
cmd.hide('all')
cmd.show('cartoon')
#cmd.hide('cartoon', 'chain E+F')
#cmd.show('ribbon', 'chain E+F')
cmd.select('zinc', 'name zn')
cmd.show('sphere', 'zinc')
cmd.set('ray_trace_mode', 3)
cmd.png('1TUP.png', width=1980, height=1080, quiet=0, ray=1, prior=False)
dump_thread()
cmd.set('ray_trace_mode', 1)
cmd.png('TUP.png', width=1980, height=1080, quiet=0, ray=1, prior=False)
cmd.quit()
-0.017600985,
0.988740742,
0.088662416,
-0.120536640,
0.000000000,
0.000000000,
-178.078948975,
1.716222763,
2.769123077,
-0.345157623,
140.398803711,
215.759094238,
-20.000000000,
]
)
# Get number of steps
nsteps = cmd.count_states()
# Render movie
frame_prefix = "atom-creation-frames/frame"
cmd.set("ray_trace_frames", 1)
frame_number = 0
for step in range(nsteps):
print("rendering frame %04d / %04d" % (step + 1, nsteps))
cmd.frame(step + 1)
cmd.png(frame_prefix + "%04d.png" % (frame_number), ray=True)
frame_number += 1
cmd.set("ray_trace_frames", 0)
def testPng(self, w, h, dpi, size):
with testing.mktemp('.png') as filename:
cmd.png(filename, w, h, dpi, ray=1)
self.assertEqual(size, Image.open(filename).size)
# where tosda find the data
A = AggregatTransferFromFile(fname)
cmd.set_view ([
-0.566527486, 0.549390495, 0.614174008,\
0.489665151, 0.823900998, -0.285317212,\
-0.662771285, 0.139101312, -0.735783637,\
0.000076182, 0.000004612, -127.713699341,\
13.776422501, -7.558099747, -3.967736244,\
-413.703674316, 669.118835449, -20.000000000 ])
# select only a few sample points
indices = np.array(np.linspace(0, A._tSteps, sample_points, endpoint=False), dtype=int)
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 = ['bcl{}'.format(i + 1) for i in range(7)]
for i, val in enumerate(values):
print('Rendering {}/{}'.format(i, sample_points))
alpha = p_to_alpha(val)
for n, bcl in enumerate(selections):
cmd.set_bond('stick_transparency', alpha[n], bcl)
cmd.label('timestamp', '"t = {0:.2f} ps"'.format(t[i] * 5.3088))
cmd.show('labels', 'timestamp')
cmd.refresh()
cmd.ray(width, height)
cmd.png(savename + "%05d.png" % i)
tresnum=int(tresnum)
srcatom=titatoms[tres]
clr = sourceclrs[source]
print resnum,tresnum,clr
labelatom=pkatoms[p]
cmd.select('bb','resi %s and name %s' %(resnum,labelatom))
cmd.show('spheres','bb')
cmd.color(clr,'bb')
atom = titatoms[tres]
cmd.select('tit','resi %s' %(tresnum))
cmd.color(clr,'tit')
cmd.show('sticks','tit')
cmd.label('tit and name %s' %atom,'resn+resi')
draw(G)
if ghostsfile1 != None:
G = pickle.load(open(ghostsfile1,'r'))
draw(G)
cmd.set('ray_trace_mode',0)
cmd.png(name+'.png',800,800)
cmd.save(name+'.pse')
cmd.quit()
def function1(userSelection):
return
cmd.extend( "yourFunction", function1 );
set_res = []
for e_tup in edges :
set_res.extend(e_tup)
set_res = set(set_res)
for ch,resi in itertools.product(chains,set_res) :
cmd.label('3H4E//'+ch+'/'+resi+'/CA','"%s%s"%(resn,resi)')
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()
outfp = os.path.join(DATA_DIR,os.path.splitext(edgef)[0]+'_hex_top.png')
print('*'*5+'Image:%s'%os.path.abspath(outfp)+'*'*5)
cmd.png(os.path.abspath(outfp))
print('-----Finished drawing from top -----')
# Set the view from the bottom
cmd.set_view (\
'-0.062551118, 0.668488383, -0.741087615,\
0.326947540, -0.687838376, -0.648059845,\
-0.942967236, -0.282835305, -0.175534144,\
0.000000000, 0.000000000, -294.413665771,\
-13.488616943, -48.363307953, -22.056068420,\
232.117980957, 356.709350586, -20.000000000' )
#cmd.ray()
outfp = os.path.join(DATA_DIR,os.path.splitext(edgef)[0]+'_hex_bottom.png')
print('*'*5+'Image:%s'%os.path.abspath(outfp)+'*'*5)
cmd.png(os.path.abspath(outfp))
import os.path
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("xyzfilename", nargs="+")
args = parser.parse_args()
import pymol
pymol.finish_launching()
from pymol import cmd
for state, xyzfilename in enumerate(args.xyzfilename):
stub = os.path.splitext(xyzfilename)[0]
# make sure no nasty characters are lurking in our filename
cleanname = stub.replace("-", "_")
cmd.load(xyzfilename, object=cleanname, state=state, quiet=0)
cmd.enable()
cmd.bg_color("white")
# pymol.preset.ball_and_stick(selection="all", mode=1)
cmd.show("lines")
# pymol.cmd.ray(width=1280, height=1024, renderer=0)
# pymol.cmd.set("antialias", 2)
cmd.set("ray_opaque_background", "off")
cmd.png(stub + ".png", width=1280, height=1024, quiet=0)
cmd.reinitialize()
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)
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)
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])
#cmd.show('surface', 'tcr')
# Create one-to-one mapping between states and frames.
cmd.mset("1 -%d" % cmd.count_states())
# Zoom viewport
#cmd.zoom('complex')
#cmd.orient('complex')
cmd.zoom('ligand')
cmd.orient('ligand')
cmd.turn('x', -90)
# Render movie
frame_prefix = 'frames/frame'
cmd.set('ray_trace_frames', 1)
cmd.set('ray_trace_frames', 0) # DEBUG
for iteration in range(niterations):
print "rendering frame %04d / %04d" % (iteration+1, niterations)
cmd.frame(iteration+1)
cmd.set('stick_transparency', float(ncfile.variables['states'][iteration, replica]) / float(nstates-1))
cmd.png(frame_prefix + '%04d.png' % (iteration), ray=True)
#cmd.mpng(frame_prefix, iteration+1, iteration+1)
#cmd.load_model(model, 'complex')
cmd.set('ray_trace_frames', 0)
# Close file
ncfile.close()
def mapColor(infile, mode, color="wolfgang.v1", reverse="OFF", position="position", target="value", adjust=0, select="OFF", IDs="OFF", maxCut="OFF", minCut="OFF", maxValue="OFF", minValue="OFF", colorDict=colorDict, altColor="OFF", dpi=300, ray=1, N=256, save="OFF", NA="OFF"):
"""
infile : Path to value input file.
mode : How should input values be treated? Options are "raw", "normalize" and "log2".
color : Color ramp to be used for value mapping.
reverse : Reverse color ramp for value mapping.
position: Position column in input file.
target : Target value column to map to each position.
adjust : Integer describing how many residues into the chain to begin coloring.
IDs : Should residue identities (chemicals) be read for each position? If so, specify identity column.
maxCut : Maximum value (cutoff) allowed for redefined value range.
minCut : Minimum value (cutoff) allowed for redefined value range.
maxValue: Maximum value for high-range normalization.
minValue: Minimum value for high-range normalization.
dpi : PyMol resolution; dots per inch.
ray : PyMol rendering mode.
N : Color ramp size.
"""
# Load color map. Note that colors come inverted:
colorMix = list(colorDict[color])
if reverse == "OFF":
colorMix.reverse()
colorMap = mpl.colors.LinearSegmentedColormap.from_list(colorMix, colors=colorMix, N=N)
color256 = colorMap(numpy.arange(N))
#for index in range(0, 255):
# r, g, b, f = color256[index]
# print index, ":", " ".join(map(str, [round(r, 2), round(g, 2), round(b, 2)]))
#print
print
print "ColorMap:", color
print "Colors:", len(color256)
print
# load input file and intensity values:
rawDict = quickBuilder(infile, i=position, x=target, mode="float")
positions = sorted(rawDict.keys())
# load reference identities if necessary:
if IDs != "OFF":
idDict = quickBuilder(infile, i=position, x=IDs, mode="string")
# threshold the raw (input) values, if necessary:
rawValues, rawPositions, rawIDs = list(), list(), list()
for position in positions:
rawValue = float(rawDict[position])
if maxCut != "OFF":
rawValue = min(rawValue, maxCut)
if minCut != "OFF":
rawValue = max(rawValue, minCut)
rawValues.append(rawValue)
rawPositions.append(position)
# load IDs if specified:
if IDs != "OFF":
rawIDs.append(idDict[position])
# normalize and transform values, if necessary:
colorValues = list()
if mode == "raw":
if minValue == "OFF" and maxValue == "OFF":
colorValues = rawValues
else:
for value in rawValues:
if minValue != "OFF" and value < float(minValue):
colorValues.append(minValue)
elif maxValue != "OFF" and value > float(maxValue):
colorValues.append(maxValue)
else:
colorValues.append(value)
elif mode == "normalize":
for value in rawValues:
if value < 0 and minValue == "OFF":
colorValues.append(-1*value/min(rawValues))
elif value < 0 and minValue != "OFF":
colorValues.append(-1*value/float(minValue))
elif value > 0 and maxValue == "OFF":
colorValues.append(value/max(rawValues))
elif value > 0 and maxValue != "OFF":
colorValues.append(value/float(maxValue))
elif value == 0:
colorValues.append(0)
elif mode == "log2":
log2Values = [ math.log(value, 2) for value in rawValues ]
for value in log2Values:
if value < 0:
colorValues.append(-1*value/min(log2Values))
elif value > 0:
colorValues.append(value/max(log2Values))
elif value == 0:
colorValues.append(0)
elif mode == "log10":
logXValues = [ numpy.log10(value) for value in rawValues ]
for value in logXValues:
if value < 0 and not value == -float('Inf'):
colorValues.append(-1*value/min(logXValues))
elif value > 0 and not value == float('Inf'):
colorValues.append(value/max(logXValues))
elif value == 0:
colorValues.append(0)
elif value in [float('Inf'), -float('Inf'), float('NaN')]:
colorValues.append(NA)
print value, NA
else:
sys.exit("Error: choose a valid mode")
# generate complete range of values:
minColor, maxColor = min(colorValues), max(colorValues)
if minValue != "OFF":
minColor = float(minValue)
if maxValue != "OFF":
maxColor = float(maxValue)
colorRanges = floatRange(minColor, maxColor, steps=N)
#[x for x in colorRanges if x != 'nan']
print
print "Input values (min, max):", min(colorValues), "-", max(colorValues)
print "Range values (min, max):", min(colorRanges), "-", max(colorRanges)
print
# color residues:
fraction = 0.1
for index in range(0, len(colorValues)):
# define residue names:
if select == "OFF":
colorName = "res" + str(int(index) + adjust)
else:
colorName = "%s and chain %s" % tuple(select.split(",")) + " and resi " + str(int(index) + adjust)
fraction = findValues(colorRanges, float(colorValues[index]), mode="less.equal", report="fraction")
# define residue color:
if altColor == "OFF":
r, g, b, f = color256[int(fraction*(N-1))]
cmd.set_color(str(colorName), str([r, g, b]))
cmd.color(colorName, colorName)
output = [int(index) + adjust, rawPositions[index], rawValues[index], fraction, colorName]
# resets residue color:
if altColor != "OFF" and rawValues[index] in altColor:
r, g, b, f = altColor[rawValues[index]]
cmd.set_color(str(colorName), str([r, g, b]))
cmd.color(colorName, colorName)
output = [int(index) + adjust, rawPositions[index], rawValues[index], fraction, colorName]
# record IDs, if requested:
if IDs != "OFF":
output.append(rawIDs[index])
#print " ".join(map(str, output))
#print len(color256)
# save image:
if save != "OFF":
print save
cmd.png((save), dpi=dpi, ray=ray)
def mke(source, reference, maximum=None, export_filename=None):
align_and_color(source, reference, maximum=maximum)
make_export_ready()
if export_filename:
cmd.png(export_filename, height=1000, ray=1)
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)
