def makeMovie(numClusts, frameRate):
real = int(numClusts)+1;
fr = int(frameRate)
movieSetup = "1 x" + str(real*fr)
cmd.mset(movieSetup)
#Load in all the system data.
for x in range(0, real):
# load the next system.
clustName = "system-" + str(x)
system = clustName + ".xyz"
cmd.load(system)
# Set the sphere scale and view
cmd.set("sphere_scale","0.5","all")
#Set the right view
cmd.set_view("0.910306633, -0.382467061, 0.158301696, 0.326706469, 0.898694992, 0.292592257, -0.254171938, -0.214630708, 0.943043232, 0.000000000, 0.000000000, -99.425979614, 10.461934090, 13.087766647, 11.786855698, 80.009132385, 118.842796326, -20.000000000")
#Set all the frame data
for x in range(0, real):
# set the current frame.
frameNum = (x*fr)+1
cmd.frame(frameNum)
clustName = "system-" + str(x)
movieState = "hide; show spheres, " + clustName
cmd.mdo(frameNum,movieState)
cmd.mview("store")
cmd.mview("reinterpolate")
cmd.mplay()
def testMset(self):
# basic tet
self.prep_movie()
self.assertEquals(cmd.count_frames(),60)
# test clearing
cmd.mset()
self.assertEquals(cmd.count_frames(),0)
# test states and frame mapping
cmd.mset("1x10 1 -10 10 -1")
cmd.frame(1)
self.assertEquals(cmd.get_frame(),1)
self.assertEquals(cmd.get("state"),"1")
cmd.frame(10)
self.assertEquals(cmd.get_frame(),10)
self.assertEquals(cmd.get("state"),"1")
cmd.frame(12)
self.assertEquals(cmd.get_frame(),12)
self.assertEquals(cmd.get("state"),"2")
cmd.frame(22)
self.assertEquals(cmd.get_frame(),22)
self.assertEquals(cmd.get("state"),"9")
cmd.frame(30)
self.assertEquals(cmd.get_frame(),30)
self.assertEquals(cmd.get("state"),"1")
def chain_pull():
cmd.mstop
cmd.mclear
coor = { 2:'[0,0,0]', 3:'[75,0,0]', 4:'[0,75,0]',
5:'[0,0,75]', 6:'[-75,0,0]', 7:'[0,-75,0]',
8:'[0,0,-75]', 9:'[75,75,0]', 10:'[-75,-75,0]',
11:'[0,75,75]', 12:'[0,-75,-75]', 13:'[75,0,75]',
14:'[-75,0,-75]', 15:'[75,75,75]', 16:'[-75,-75,-75]',
17:'[75,-75,0]', 18:'[-75,75,0]', 19:'[0,75,-75]',
20:'[0,-75,75]', 21:'[75,0,-75]', 22:'[-75,0,75]',
23:'[75,75,-75]', 24:'[75,-75,75]', 25:'[-75,75,75]',
26:'[-75,-75,75]',27:'[75,-75,-75]',28:'[-75,-75,-75]'}
chainPullList = chain_contact()
if chainPullList == False:
return False
chainPullLen = len(chainPullList)
frames = 1+chainPullLen+172+chainPullLen+172
cmd.mset('1','%s'%frames)
i = chainPullLen+2
for h in range(2,i):
print 'translate %s,%s'%(coor[h],chainPullList[h-2])
cmd.mdo(h,'translate %s,%s'%(coor[h],chainPullList[h-2]))
cmd.mdo(i,'zoom all')
util.mroll(i+1,i+171,1)
i += 172
for g in range(i,chainPullLen+i):
c = coor[(g-i)+2].replace('7','-7').replace('--','-')
cmd.mdo(g,'translate %s,%s'%(c,chainPullList[g-i]))
g = chainPullLen+i
cmd.mdo(g,'zoom all')
util.mroll(g+1,g+171,1)
def testMset(self):
# basic tet
self.prep_movie()
self.assertEquals(cmd.count_frames(), 60)
# test clearing
cmd.mset()
self.assertEquals(cmd.count_frames(), 0)
# test states and frame mapping
cmd.mset("1x10 1 -10 10 -1")
cmd.frame(1)
self.assertEquals(cmd.get_frame(), 1)
self.assertEquals(cmd.get("state"), "1")
cmd.frame(10)
self.assertEquals(cmd.get_frame(), 10)
self.assertEquals(cmd.get("state"), "1")
cmd.frame(12)
self.assertEquals(cmd.get_frame(), 12)
self.assertEquals(cmd.get("state"), "2")
cmd.frame(22)
self.assertEquals(cmd.get_frame(), 22)
self.assertEquals(cmd.get("state"), "9")
cmd.frame(30)
self.assertEquals(cmd.get_frame(), 30)
self.assertEquals(cmd.get("state"), "1")
def testScene(self):
cmd.fragment('ala', 'm1')
cmd.fragment('gly', 'm2')
cmd.create('m2', 'm2', 1, 2)
cmd.create('m2', 'm2', 1, 3)
cmd.create('m2', 'm2', 1, 4)
# store
cmd.show_as('sticks', 'm1')
cmd.show_as('spheres', 'm2')
cmd.color('blue', 'm1')
cmd.color('yellow', 'm2')
view_001 = cmd.get_view()
cmd.scene('new', 'store', 'hello world')
# store
cmd.frame(3)
cmd.show_as('lines')
cmd.color('red')
cmd.turn('x', 45)
view_002 = cmd.get_view()
cmd.scene('new', 'store')
# we actually don't know the auto naming counter
# self.assertEqual(cmd.get_scene_list(), ['001', '002'])
names = cmd.get_scene_list()
# recall
cmd.scene(names[0], 'recall', animate=0)
self.assertArrayEqual(view_001, cmd.get_view(), delta=1e-3)
self.assertEqual(cmd.count_atoms('m1'), cmd.count_atoms('color blue'))
self.assertEqual(cmd.count_atoms('m1'), cmd.count_atoms('rep sticks'))
self.assertEqual(cmd.count_atoms('m2'),
cmd.count_atoms('color yellow'))
self.assertEqual(cmd.count_atoms('m2'), cmd.count_atoms('rep spheres'))
self.assertNotEqual(cmd.get_wizard(), None)
self.assertEqual(cmd.get_state(), 1)
# recall
cmd.scene(names[1], 'recall', animate=0)
self.assertArrayEqual(view_002, cmd.get_view(), delta=1e-3)
self.assertEqual(0, cmd.count_atoms('color blue'))
self.assertEqual(0, cmd.count_atoms('rep sticks'))
self.assertEqual(cmd.count_atoms(), cmd.count_atoms('color red'))
self.assertEqual(cmd.count_atoms(), cmd.count_atoms('rep lines'))
self.assertEqual(cmd.get_wizard(), None)
self.assertEqual(cmd.get_state(), 3)
# with movie (not playing) it must not recall the state
cmd.mset('1-4')
cmd.frame(1)
cmd.scene(names[1], 'recall', animate=0)
self.assertEqual(cmd.get_state(), 1)
# rename and delete
cmd.scene('F2', 'store')
cmd.scene(names[0], 'rename', new_key='F1')
cmd.scene(names[1], 'delete')
self.assertEqual(cmd.get_scene_list(), ['F1', 'F2'])
def makmovie(event):
try:
cmd.mset("1 -%s"%fent.get())
scriptent.delete(0,100000000)
scriptent.insert(0,0)
except:
showinfo('Alert!', 'Enter the amount of frames to be in the movie')
interior.mainloop()
def testScene(self):
cmd.fragment('ala', 'm1')
cmd.fragment('gly', 'm2')
cmd.create('m2', 'm2', 1, 2)
cmd.create('m2', 'm2', 1, 3)
cmd.create('m2', 'm2', 1, 4)
# store
cmd.show_as('sticks', 'm1')
cmd.show_as('spheres', 'm2')
cmd.color('blue', 'm1')
cmd.color('yellow', 'm2')
view_001 = cmd.get_view()
cmd.scene('new', 'store', 'hello world')
# store
cmd.frame(3)
cmd.show_as('lines')
cmd.color('red')
cmd.turn('x', 45)
view_002 = cmd.get_view()
cmd.scene('new', 'store')
# we actually don't know the auto naming counter
# self.assertEqual(cmd.get_scene_list(), ['001', '002'])
names = cmd.get_scene_list()
# recall
cmd.scene(names[0], 'recall', animate=0)
self.assertArrayEqual(view_001, cmd.get_view(), delta=1e-3)
self.assertEqual(cmd.count_atoms('m1'), cmd.count_atoms('color blue'))
self.assertEqual(cmd.count_atoms('m1'), cmd.count_atoms('rep sticks'))
self.assertEqual(cmd.count_atoms('m2'), cmd.count_atoms('color yellow'))
self.assertEqual(cmd.count_atoms('m2'), cmd.count_atoms('rep spheres'))
self.assertNotEqual(cmd.get_wizard(), None)
self.assertEqual(cmd.get_state(), 1)
# recall
cmd.scene(names[1], 'recall', animate=0)
self.assertArrayEqual(view_002, cmd.get_view(), delta=1e-3)
self.assertEqual(0, cmd.count_atoms('color blue'))
self.assertEqual(0, cmd.count_atoms('rep sticks'))
self.assertEqual(cmd.count_atoms(), cmd.count_atoms('color red'))
self.assertEqual(cmd.count_atoms(), cmd.count_atoms('rep lines'))
self.assertEqual(cmd.get_wizard(), None)
self.assertEqual(cmd.get_state(), 3)
# with movie (not playing) it must not recall the state
cmd.mset('1-4')
cmd.frame(1)
cmd.scene(names[1], 'recall', animate=0)
self.assertEqual(cmd.get_state(), 1)
# rename and delete
cmd.scene('F2', 'store')
cmd.scene(names[0], 'rename', new_key='F1')
cmd.scene(names[1], 'delete')
self.assertEqual(cmd.get_scene_list(), ['F1', 'F2'])
def testGetMovieLocked(self):
self.assertEqual(cmd.get_movie_locked(), 0)
cmd.mset('1x1')
cmd.mdo(1, 'cmd.color("blue")')
s = cmd.get_session()
cmd.set_session(s)
self.assertEqual(cmd.get_movie_locked(), 1)
cmd.set('security', 0)
cmd.set_session(s)
self.assertEqual(cmd.get_movie_locked(), 0)
def setup_pymol():
"""Sets up PyMOL for making animations."""
pymol.finish_launching() # Prevent threading errors
# Configure global settings
cmd.set('scene_buttons', 1)
cmd.set('matrix_mode', 1)
cmd.set('movie_panel', 1)
# Configure quality settings
cmd.mset("1 x500")
cmd.set('ray_trace_frames', 1)
cmd.viewport(800, 800)
def setup_pymol():
"""Sets up PyMOL for making animations."""
pymol.finish_launching() # Prevent threading errors
# Configure global settings
cmd.set('scene_buttons', 1)
cmd.set('matrix_mode', 1)
cmd.set('movie_panel', 1)
# Configure quality settings
cmd.mset("1 x500")
cmd.set('ray_trace_frames', 1)
cmd.viewport(800, 800)
def convert_spin(self):
'''spin the protein'''
if self.argsLength > 1 and self.args[1] == 'off':
cmd.mstop()
cmd.mset()
pymSpin = 'PyMOL: mstop; mset\n\n'
else:
cmd.mset('1 x180')
util.mroll(1,180,1)
cmd.mplay()
pymSpin = 'PyMOL: mset 1 x180; util.mroll(1,180,1); mplay'
print pymSpin
def convert_spin(self):
'''spin the protein'''
if self.argsLength > 1 and self.args[1] == 'off':
cmd.mstop()
cmd.mset()
pymSpin = 'PyMOL: mstop; mset\n\n'
else:
cmd.mset('1 x180')
util.mroll(1, 180, 1)
cmd.mplay()
pymSpin = 'PyMOL: mset 1 x180; util.mroll(1,180,1); mplay'
print pymSpin
def test_add_scenes(self):
cmd.fragment('gly', 'm1')
cmd.scene('001', 'store')
cmd.turn('x', 90)
cmd.scene('002', 'store')
movie.add_scenes()
self.assertEqual(cmd.count_frames(), 615)
cmd.mset()
movie.add_scenes(['001', '002'], pause=3)
self.assertEqual(cmd.count_frames(), 315)
cmd.mset()
movie.add_scenes('["001", "002"]') # string
self.assertEqual(cmd.count_frames(), 615)
def test_add_scenes(self):
cmd.fragment('gly', 'm1')
cmd.scene('001', 'store')
cmd.turn('x', 90)
cmd.scene('002', 'store')
movie.add_scenes()
self.assertEqual(cmd.count_frames(), 615)
cmd.mset()
movie.add_scenes(['001', '002'], pause=3)
self.assertEqual(cmd.count_frames(), 315)
cmd.mset()
movie.add_scenes('["001", "002"]') # string
self.assertEqual(cmd.count_frames(), 615)
def color_L1(arg0, arg1, arg2, arg3, arg4=1, MOVIE=0, bgcol='hydrogen'):
'''
DESCRIPTION
Brief description: Colors the identified L1 features
'''
# Running on pymol cmdline
#run ./pymol_scripts/color_L1.py
#color_L1 pdb/1ruz.pdb, 78 137 158 188 241 292 573, green, 2
filename = arg0
cmd.load(filename)
cmd.hide('everything')
#cmd.cartoon('rectangle')
cmd.show('cartoon')
cmd.set('reflect', 0.5)
Feature_set = [int(j) for j in np.array(arg1.split())]
col = arg2
L = int(arg3)
#reset color to gray
if arg4 == '1':
print('coloring gray')
cmd.do('color ' + bgcol)
print(arg4)
F = np.array([np.arange(i - L, i + L + 1) for i in Feature_set]).flatten()
for feature in F:
print("resi " + str(feature))
cmd.color(col, "resi " + str(feature))
cmd.viewport("2560,1920")
if MOVIE == "0":
MOVIE = False
if MOVIE:
cmd.show('surface')
cmd.mset('1 x 10')
cmd.util.mroll(1, 10, 1)
cmd.mplay
cmd.viewport("2560,1920")
cmd.set("ray_trace_frames", 1)
cmd.set("cache_frames", 0)
cmd.mclear
cmd.mpng('zXXXmov')
def animate(self,cleanup=0):
if not cleanup:
cmd.set("security",0)
cmd.set_session(self.get_sess("$PYMOL_DATA/big_demo/animate.pse"))
cmd.rock(1)
cmd.set("field_of_view",23)
cmd.rock(1)
cmd.set("sweep_mode",3)
cmd.set("sweep_angle",10)
cmd.do("replace_wizard toggle, Molecular Animation")
else:
cmd.set("mesh_width",1)
cmd.set("field_of_view",20)
cmd.rock(0)
cmd.mset()
cmd.mstop()
def highlight_chains():
cmd.mstop()
cmd.mclear()
cmd.mset()
glb.update()
colors = ['blue', 'orange', 'silver', 'green', 'yellow',
'purple', 'brightorange', 'lightblue', 'lightorange',
'pink', 'forest', 'firebrick', 'paleyellow', 'salmon',
'ruby', 'wheat', 'lightmagenta', 'nitblue']
chains = []
numChains = 0
objects = cmd.get_names('all')
for obj in objects:
split = obj.split('Chain-')
if len(split) == 2:
chains.append(split[1])
numChains += 1
numFrames = (numChains*200)+70
cmd.mset('1', numFrames)
cmd.mdo(1,'color red, all; hide cartoon, all')
cmd.orient()
cmd.mview('store', '1')
colorCount = 0
frameCount = 1
for i in chains:
cmd.orient('chain ' + i)
cmd.mview('store', frameCount+59)
cmd.mview('store', frameCount+115)
flash_chain(i, frameCount+59, 'red', colors[colorCount])
cmd.orient()
cmd.turn('x', '270')
cmd.turn('y', '180')
cmd.mview('store', frameCount+150)
cmd.mview('store', frameCount+170)
colorCount += 1
frameCount += 200
if(frameCount > numFrames-100):
cmd.orient()
cmd.mdo(numFrames,'mstop')
cmd.mview('store', (numChains*200)+70)
cmd.mview('interpolate')
cmd.show('ribbon')
cmd.color('red', 'all')
def gen_frames(pdb):
cmd.reinitialize()
pdb_filename = "./pdbs/n" + pdb + ".pdb"
cmd.load(pdb_filename)
cmd.orient()
cmd.show_as("cartoon")
cmd.color("marine")
cmd.set("opaque_background", 0)
cmd.bg_color("white")
cmd.mset("1 x90")
cmd.util.mroll(1, 90, 1)
frame_folder_path = "./frames/" + pdb + "/"
frame_prefix = frame_folder_path + "frame"
cmd.mpng(frame_prefix)
final_frame = frame_prefix + "0090.png"
while not os.path.exists(final_frame):
time.sleep(0.1)
def animate(self,cleanup=0):
if not cleanup:
cmd.set("security",0)
cmd.set_session(self.get_sess("$PYMOL_DATA/big_demo/animate.pse"))
cmd.rock(1)
cmd.set("field_of_view",23)
cmd.rock(1)
cmd.set("sweep_mode",3)
cmd.set("sweep_angle",10)
cmd.set("sphere_mode",5)
cmd.do("replace_wizard toggle, Molecular Animation")
else:
cmd.set("mesh_width",1)
cmd.set("field_of_view",20)
cmd.rock(0)
cmd.mset()
cmd.mstop()
def testMdelete(self):
cmd.mset("1x10 1 -10 10 -1")
# 1-10 = state 1
# 11-20 = states 1..10
# 21-30 = states 10..1
cmd.mdelete(count=10, frame=11)
# simple delete
self.assertEquals(cmd.count_frames(), 20)
# test state mapping
cmd.frame(1)
self.assertEquals(cmd.get("state"), "1")
cmd.frame(11)
self.assertEquals(cmd.get("state"), "10")
cmd.frame(20)
self.assertEquals(cmd.get("state"), "1")
def testMdelete(self):
cmd.mset("1x10 1 -10 10 -1")
# 1-10 = state 1
# 11-20 = states 1..10
# 21-30 = states 10..1
cmd.mdelete(count=10, frame=11)
# simple delete
self.assertEquals(cmd.count_frames(),20)
# test state mapping
cmd.frame(1)
self.assertEquals(cmd.get("state"),"1")
cmd.frame(11)
self.assertEquals(cmd.get("state"),"10")
cmd.frame(20)
self.assertEquals(cmd.get("state"),"1")
def make_all():
#make the whole movie
global views
global frames
global models
#first get total number of frames
ftot = 0
i = 0
setcommand = ""
for nframes in frames[:-1]:
ftot += nframes
if models.has_key(i):
setcommand += " " + models[i] + " "
else:
setcommand += " 1 x%i" % nframes
i += 1
#initialize movie
#cmd.mset("1 x%i" % ftot)
#cmd.mset("1 x50 1 -30 30 x20")
cmd.mset( setcommand )
#loop through views
start_view = views[0][:]
i = 0
first_frame = 1
for view in views[1:]:
end_view = view[:]
if settings.has_key(i):
movs.animate_transition( start_view, end_view, frames[i], first_frame, settings[i] )
elif fades.has_key(i):
movs.animate_transition( start_view, end_view, frames[i], first_frame, fades[i] )
else:
movs.animate_transition( start_view, end_view, frames[i], first_frame )
#add an action
if actions.has_key(i):
mdo_cmd = actions[i]#+";set_view ("+str( views[i] )+")"
print mdo_cmd
cmd.mdo(first_frame, mdo_cmd)
first_frame += frames[i]
i += 1
start_view = end_view[:]
cmd.frame(1)
def make_all():
#make the whole movie
global views
global frames
global models
#first get total number of frames
ftot = 0
setcommand = ""
for i, nframes in enumerate(frames[:-1]):
ftot += nframes
if i in models:
setcommand += " " + models[i] + " "
else:
setcommand += " 1 x%i" % nframes
#initialize movie
#cmd.mset("1 x%i" % ftot)
#cmd.mset("1 x50 1 -30 30 x20")
cmd.mset(setcommand)
#loop through views
start_view = views[0][:]
first_frame = 1
for i, view in enumerate(views[1:]):
end_view = view[:]
if i in settings:
movs.animate_transition(start_view, end_view, frames[i],
first_frame, settings[i])
elif i in fades:
movs.animate_transition(start_view, end_view, frames[i],
first_frame, fades[i])
else:
movs.animate_transition(start_view, end_view, frames[i],
first_frame)
#add an action
if i in actions:
mdo_cmd = actions[i] #+";set_view ("+str( views[i] )+")"
print mdo_cmd
cmd.mdo(first_frame, mdo_cmd)
first_frame += frames[i]
start_view = end_view[:]
cmd.frame(1)
def make_all():
# make the whole movie
global views
global frames
global models
# first get total number of frames
ftot = 0
setcommand = ""
for i, nframes in enumerate(frames[:-1]):
ftot += nframes
if i in models:
setcommand += " " + models[i] + " "
else:
setcommand += " 1 x%i" % nframes
# initialize movie
# cmd.mset("1 x%i" % ftot)
# cmd.mset("1 x50 1 -30 30 x20")
cmd.mset(setcommand)
# loop through views
start_view = views[0][:]
first_frame = 1
for i, view in enumerate(views[1:]):
end_view = view[:]
if i in settings:
movs.animate_transition(start_view, end_view, frames[i], first_frame, settings[i])
elif i in fades:
movs.animate_transition(start_view, end_view, frames[i], first_frame, fades[i])
else:
movs.animate_transition(start_view, end_view, frames[i], first_frame)
# add an action
if i in actions:
mdo_cmd = actions[i] # +";set_view ("+str( views[i] )+")"
print mdo_cmd
cmd.mdo(first_frame, mdo_cmd)
first_frame += frames[i]
start_view = end_view[:]
cmd.frame(1)
def test_scenes(self):
self._load_example()
cmd.scene('s1', 'store')
cmd.enable('g1')
cmd.scene('s2', 'store')
cmd.mset('1x4')
cmd.mview('store', 1, scene='s2')
cmd.mview('store', 4, scene='s1')
with testing.mkdtemp() as tempdir:
# export
prefix = os.path.join(tempdir, 'frame')
cmd.mpng(prefix, width=100, height=100)
img = self.get_imagearray(prefix + '0002.png')
self.assertImageHasColor('red', img)
self.assertImageHasColor('blue', img)
img = self.get_imagearray(prefix + '0003.png')
self.assertImageHasNotColor('red', img)
self.assertImageHasColor('blue', img)
def testMpng(self, modal):
import glob, os
shape2 = (100, 100)
cmd.mset("1x4")
cmd.mdo(1, 'bg_color red')
cmd.mdo(3, 'bg_color blue')
with testing.mkdtemp() as dirname:
cmd.mpng(os.path.join(dirname, 'image'), width=shape2[0], height=shape2[1])
filenames = glob.glob(os.path.join(dirname, 'image*.png'))
filenames.sort()
self.assertEqual(4, len(filenames))
img = self.get_imagearray(filenames[0])
self.assertEqual(img.shape[:2], shape2)
self.assertImageHasColor('red', img)
img = self.get_imagearray(filenames[-1])
self.assertEqual(img.shape[:2], shape2)
self.assertImageHasColor('blue', img)
def test_scenes(self):
self._load_example()
cmd.scene('s1', 'store')
cmd.enable('g1')
cmd.scene('s2', 'store')
cmd.mset('1x4')
cmd.mview('store', 1, scene='s2')
cmd.mview('store', 4, scene='s1')
with testing.mkdtemp() as tempdir:
# export
prefix = os.path.join(tempdir, 'frame')
cmd.mpng(prefix, width=100, height=100)
img = self.get_imagearray(prefix + '0002.png')
self.assertImageHasColor('red', img)
self.assertImageHasColor('blue', img)
img = self.get_imagearray(prefix + '0003.png')
self.assertImageHasNotColor('red', img)
self.assertImageHasColor('blue', img)
def set_browse(self,browse):
# allow user to focus on only a subset of the compounds
self.browse = browse
if self.browse == 1:
print " Filter: Browsing all compounds."
cmd.mset() # all states visible
elif self.object==None:
print " Filter-Error: please choose an object first"
else:
self.check_object_dict()
if self.browse == 2:
print " Filter: Browsing accepted compounds."
target = accept_str
elif self.browse == 3:
print " Filter: Browsing rejected compounds."
target = reject_str
elif self.browse == 4:
print " Filter: Browsing deferred compounds."
target = defer_str
lst = []
sd = self.state_dict
sdo = self.dict[self.object]
if self.browse<5:
for a in sdo.keys():
if sdo[a]==target:
lst.append(sd[a])
else:
print " Filter: Browsing remaining compounds"
for a in sd.keys():
if not sdo.has_key(a):
lst.append(sd[a])
lst.sort()
if len(lst)==0:
print " Filter-Error: No matching compounds."
cmd.mset(' '.join(map(str,lst)))
cmd.rewind()
cmd.refresh_wizard()
def set_browse(self,browse):
# allow user to focus on only a subset of the compounds
self.browse = browse
if self.browse == 1:
print(" Filter: Browsing all compounds.")
cmd.mset() # all states visible
elif self.object is None:
print(" Filter-Error: please choose an object first")
else:
self.check_object_dict()
if self.browse == 2:
print(" Filter: Browsing accepted compounds.")
target = accept_str
elif self.browse == 3:
print(" Filter: Browsing rejected compounds.")
target = reject_str
elif self.browse == 4:
print(" Filter: Browsing deferred compounds.")
target = defer_str
lst = []
sd = self.state_dict
sdo = self.dict[self.object]
if self.browse<5:
for a in list(sdo.keys()):
if sdo[a]==target:
lst.append(sd[a])
else:
print(" Filter: Browsing remaining compounds")
for a in sd.keys():
if a not in sdo:
lst.append(sd[a])
lst.sort()
if len(lst)==0:
print(" Filter-Error: No matching compounds.")
cmd.mset(' '.join(map(str,lst)))
cmd.rewind()
cmd.refresh_wizard()
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')
def test_mdo(self):
self._load_example()
cmd.mset('1x3')
cmd.mdo(1, 'disable m1')
cmd.mdo(2, 'enable m1')
cmd.mdo(3, 'enable g1')
with testing.mkdtemp() as tempdir:
# export
prefix = os.path.join(tempdir, 'frame')
cmd.mpng(prefix, width=100, height=100)
img = self.get_imagearray(prefix + '0001.png')
self.assertImageHasNotColor('red', img)
self.assertImageHasColor('blue', img)
img = self.get_imagearray(prefix + '0002.png')
self.assertImageHasNotColor('red', img)
self.assertImageHasColor('blue', img)
img = self.get_imagearray(prefix + '0003.png')
self.assertImageHasColor('red', img)
self.assertImageHasColor('blue', img)
def testMpng(self, modal):
import glob, os
shape2 = (100, 100)
cmd.mset("1x4")
cmd.mdo(1, 'bg_color red')
cmd.mdo(3, 'bg_color blue')
with testing.mkdtemp() as dirname:
cmd.mpng(os.path.join(dirname, 'image'),
width=shape2[0],
height=shape2[1])
filenames = glob.glob(os.path.join(dirname, 'image*.png'))
filenames.sort()
self.assertEqual(4, len(filenames))
img = self.get_imagearray(filenames[0])
self.assertEqual(img.shape[:2], shape2)
self.assertImageHasColor('red', img)
img = self.get_imagearray(filenames[-1])
self.assertEqual(img.shape[:2], shape2)
self.assertImageHasColor('blue', img)
def test_mdo(self):
self._load_example()
cmd.mset('1x3')
cmd.mdo(1, 'disable m1')
cmd.mdo(2, 'enable m1')
cmd.mdo(3, 'enable g1')
with testing.mkdtemp() as tempdir:
# export
prefix = os.path.join(tempdir, 'frame')
cmd.mpng(prefix, width=100, height=100)
img = self.get_imagearray(prefix + '0001.png')
self.assertImageHasNotColor('red', img)
self.assertImageHasColor('blue', img)
img = self.get_imagearray(prefix + '0002.png')
self.assertImageHasNotColor('red', img)
self.assertImageHasColor('blue', img)
img = self.get_imagearray(prefix + '0003.png')
self.assertImageHasColor('red', img)
self.assertImageHasColor('blue', img)
cmd.show('surface', 'chain A+B+C')
cmd.show('cartoon', 'chain E+F')
cmd.scene('S0', action='store', view=0, frame=0, animate=-1)
cmd.show('cartoon')
cmd.hide('surface')
cmd.scene('S1', action='store', view=0, frame=0, animate=-1)
cmd.hide('cartoon', 'chain A+B+C')
cmd.show('mesh', 'chain A')
cmd.show('sticks', 'chain A+B+C')
cmd.scene('S2', action='store', view=0, frame=0, animate=-1)
cmd.set('ray_trace_mode', 0)
cmd.mset(1, 500)
cmd.frame(0)
cmd.scene('S0')
cmd.mview()
cmd.frame(60)
cmd.set_view((-0.175534308, -0.331560850, -0.926960170,
0.541812420, 0.753615797, -0.372158051,
0.821965039, -0.567564785, 0.047358301,
0.000000000, 0.000000000, -249.619018555,
58.625568390, 15.602619171, 77.781631470,
196.801528931, 302.436492920, -20.000000000))
cmd.mview()
cmd.frame(90)
# Load trajectory
cmd.load_traj(trajectory_temporary_filename, object='system')
# Align all states
if solute == 'dna':
cmd.intra_fit('name P') # DNA
else:
cmd.intra_fit('solute') # protein
# Zoom viewport
cmd.zoom('solute')
cmd.orient('solute')
# Create one-to-one mapping between states and frames.
cmd.mset("1 -%d" % nframes)
# Delete first frame
cmd.mdelete("1")
# Render movie
cmd.set('ray_trace_frames', 0)
#nframes = 1
for frame in range(nframes):
print("rendering frame %04d / %04d" % (frame+1, nframes))
cmd.set('suspend_updates', 'on')
cmd.frame(frame+1)
# Show only ions
cmd.hide('spheres', 'all')
# Determine oxygen indices for cations and anions
def init_movie():
cmd.mdelete()
cmd.mview('reset')
frames = duration * 30
cmd.mset(f'1x{frames}')
return frames
cmd.hide('all')
cmd.show('cartoon', 'receptor')
cmd.show('sticks', 'ligand')
util.cbay('ligand')
cmd.color('green', 'mhc')
cmd.color('red', 'tcr')
cmd.show('surface', 'mhc')
cmd.set('transparency', 0.65)
cmd.set('surface_mode', 3)
cmd.set('surface_color', 'white')
#cmd.show('lines', '(not hydrogen) within 5 of ligand')
#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)
def rotate_y():
cmd.mset()
cmd.mset('1', '180')
cmd.util.mroll('1', '180', '1')
cmd.mplay()
def Ligand_Pull():
glb.update()
cmd.mstop()
cmd.mclear()
cmd.mset('1', '442')
cmd.hide('everything')
cmd.remove('resn HOH')
cmd.color('green', 'all')
objects = cmd.get_names('all')
if 'ligands' in objects:
cmd.set('stick_radius', '0.3')
glb.procolor('ligands around 6','sticks','cpk','cartoon')
glb.procolor('ligands','spheres','orange',None)
cmd.set("cartoon_fancy_helices", "1")
cmd.set("cartoon_fancy_sheets", "1")
cmd.set('cartoon_transparency', '0.5')
cmd.zoom()
cmd.orient()
cmd.mdo(1,'orient')
cmd.mdo(2,'translate [2,0,0],ligands;')
cmd.mdo(3,'translate [2,0,0],ligands;')
cmd.mdo(4,'translate [2,0,0],ligands;')
cmd.mdo(5,'translate [2,0,0],ligands;')
cmd.mdo(6,'translate [2,0,0],ligands;')
cmd.mdo(7,'translate [2,0,0],ligands;')
cmd.mdo(8,'translate [2,0,0],ligands;')
cmd.mdo(9,'translate [2,0,0],ligands;')
cmd.mdo(10,'translate [2,0,0],ligands;')
cmd.mdo(11,'translate [2,0,0],ligands;')
cmd.mdo(12,'translate [2,0,0],ligands;')
cmd.mdo(13,'translate [2,0,0],ligands;')
cmd.mdo(14,'translate [2,0,0],ligands;')
cmd.mdo(15,'translate [2,0,0],ligands;')
cmd.mdo(16,'translate [2,0,0],ligands;')
cmd.mdo(17,'translate [2,0,0],ligands;')
cmd.mdo(18,'translate [2,0,0],ligands;')
cmd.mdo(19,'translate [2,0,0],ligands;')
cmd.mdo(20,'translate [2,0,0],ligands;')
cmd.mdo(21,'translate [2,0,0],ligands;')
cmd.mdo(22,'translate [2,0,0],ligands;')
cmd.mdo(23,'translate [2,0,0],ligands;')
cmd.mdo(24,'translate [2,0,0],ligands;')
cmd.mdo(25,'translate [2,0,0],ligands;')
cmd.mdo(26,'translate [2,0,0],ligands;')
cmd.mdo(27,'translate [2,0,0],ligands;')
cmd.mdo(28,'translate [2,0,0],ligands;')
cmd.mdo(29,'translate [2,0,0],ligands;')
cmd.mdo(30,'translate [2,0,0],ligands;')
cmd.mdo(31,'translate [2,0,0],ligands;')
cmd.mdo(32,'translate [2,0,0],ligands;')
cmd.mdo(33,'translate [2,0,0],ligands;')
cmd.mdo(34,'translate [2,0,0],ligands;')
cmd.mdo(35,'translate [2,0,0],ligands;')
cmd.mdo(36,'translate [2,0,0],ligands;')
cmd.mdo(37,'translate [2,0,0],ligands;')
cmd.mdo(38,'translate [2,0,0],ligands;')
cmd.mdo(39,'translate [2,0,0],ligands;')
cmd.mdo(40,'translate [2,0,0],ligands;')
cmd.mdo(41,'translate [2,0,0],ligands;')
cmd.mdo(42,'orient')
cmd.util.mroll('42','222','1')
cmd.mdo(223,'translate [-2,0,0],ligands;')
cmd.mdo(224,'translate [-2,0,0],ligands;')
cmd.mdo(225,'translate [-2,0,0],ligands;')
cmd.mdo(226,'translate [-2,0,0],ligands;')
cmd.mdo(227,'translate [-2,0,0],ligands;')
cmd.mdo(228,'translate [-2,0,0],ligands;')
cmd.mdo(229,'translate [-2,0,0],ligands;')
cmd.mdo(230,'translate [-2,0,0],ligands;')
cmd.mdo(231,'translate [-2,0,0],ligands;')
cmd.mdo(232,'translate [-2,0,0],ligands;')
cmd.mdo(233,'translate [-2,0,0],ligands;')
cmd.mdo(234,'translate [-2,0,0],ligands;')
cmd.mdo(235,'translate [-2,0,0],ligands;')
cmd.mdo(236,'translate [-2,0,0],ligands;')
cmd.mdo(237,'translate [-2,0,0],ligands;')
cmd.mdo(238,'translate [-2,0,0],ligands;')
cmd.mdo(239,'translate [-2,0,0],ligands;')
cmd.mdo(240,'translate [-2,0,0],ligands;')
cmd.mdo(241,'translate [-2,0,0],ligands;')
cmd.mdo(242,'translate [-2,0,0],ligands;')
cmd.mdo(243,'translate [-2,0,0],ligands;')
cmd.mdo(244,'translate [-2,0,0],ligands;')
cmd.mdo(245,'translate [-2,0,0],ligands;')
cmd.mdo(246,'translate [-2,0,0],ligands;')
cmd.mdo(247,'translate [-2,0,0],ligands;')
cmd.mdo(248,'translate [-2,0,0],ligands;')
cmd.mdo(249,'translate [-2,0,0],ligands;')
cmd.mdo(250,'translate [-2,0,0],ligands;')
cmd.mdo(251,'translate [-2,0,0],ligands;')
cmd.mdo(252,'translate [-2,0,0],ligands;')
cmd.mdo(253,'translate [-2,0,0],ligands;')
cmd.mdo(254,'translate [-2,0,0],ligands;')
cmd.mdo(255,'translate [-2,0,0],ligands;')
cmd.mdo(256,'translate [-2,0,0],ligands;')
cmd.mdo(257,'translate [-2,0,0],ligands;')
cmd.mdo(258,'translate [-2,0,0],ligands;')
cmd.mdo(259,'translate [-2,0,0],ligands;')
cmd.mdo(260,'translate [-2,0,0],ligands;')
cmd.mdo(261,'translate [-2,0,0],ligands;')
cmd.mdo(262,'translate [-2,0,0],ligands;')
cmd.mdo(263,'orient')
cmd.util.mroll('264','442','1')
else:
showinfo('No ligands','There are no ligands in this PDB.')
def prep_movie(self):
cmd.mset("1x60")
from glob import glob
from pymol import cmd
file_list = glob("mov*.pdb")
for file in file_list:
cmd.color("white")
cmd.load(file,"mov")
cmd.hide("everything")
cmd.show("nb_spheres")
cmd.color("white")
cmd.recolor
cmd.mset("1 -%d"%len(file_list))
def _setup_movie(self, rep):
cmd.load(self.datafile('1aon.pdb.gz'))
cmd.show_as(rep)
cmd.orient()
cmd.mset('1x100')
pymol.movie.roll(1, cmd.count_frames(), 0, 'y')
import pymol
from pymol import cmd, util
from glob import glob
import re
#cmd.load('nucleophilic.pse')
cmd.mset()
cmd.rewind()
nloop = 4
seconds = 4
fps = 30
degrees = 30
#cmd.mset(1, )
nframes = seconds * fps
for loop in range(nloop):
cmd.movie.add_nutate(seconds,degrees)
objname = '2020-08-20-benzotriazoles-dockscores-x10876'
cmd.load(objname + '.sdf')
cmd.hide('sticks', 'hydrogen')
cmd.mview('store', 1, object=objname, state=1)
cmd.mview('store', nloop*seconds*fps, object=objname, state=nloop*seconds*fps)
cmd.viewport(720, 720)
#movie.produce('nucleophilic_displacement.mov', mode='ray')
# let's dress it up a little bit
cmd.show("sticks","demo")
cmd.show("spheres","resi 10")
cmd.color("yellow","resi 5 and element C")
# now loop, updating the coordinates and appending the model
# onto 99 subsequent frames...
m = cmd.get_model()
for a in range(1,100):
for a in m.atom:
a.coord[0]+=(random()-0.5)*0.1
a.coord[1]+=(random()-0.5)*0.1
a.coord[2]+=(random()-0.5)*0.1
cmd.load_model(m,"demo") # NOTE: no state number provided -> appends
# now define the movie with short pauses at beginning and and
cmd.mset("1 x15 1 -100 100 x15")
# now play the movie...
cmd.mplay()
# by default, PyMOL plays ~30 fps.
# "set movie_delay=0" to see maximum speed...
# All of the following imports are distributed with python3 by default
import sys
import time
import FindPyMol
# following try catch is meant to initiate a trouble shooting step if pymol cannot be imported
try:
from pymol import finish_launching, cmd
except ImportError:
FindPyMol.pymol_not_found()
sys.exit(1)
if __name__ == '__main__':
code = 0
while True:
code = input("Enter 4 letter name of PDB protien file: ")
if type(code) is not str:
print("enter a valid code string")
else:
break
finish_launching(['pymol', '-q']) # open pymol in quiet mode
time.sleep(2)
cmd.fetch(code) # gets protein code to load in
cmd.spectrum()
cmd.mset("1x180")
cmd.movie.roll(1, 180, 1)
cmd.movie.produce("movietest", mode="draw")
def get_extent(self):
return [
self.vert.min(0).tolist(),
self.vert.max(0).tolist(),
]
class myCallbackDynamic(myCallback):
'''
Dynamic object which updates vertex coordinates every frame
'''
def __call__(self):
self.update(cmd.get_frame() * 2)
myCallback.__call__(self)
# load it into PyMOL
for b in range(0, 63):
cmd.load_callback(myCallback(b), 'gl03', b + 1)
cmd.load_callback(myCallbackDynamic(), 'gl03dyn', 1)
# give us a nice view
cmd.turn('z',20)
cmd.turn('y',20)
cmd.turn('x',20)
cmd.mset('1-62')
cmd.mplay()
cmd.color("cyan", "chain B")
cmd.color("green", "chain H")
cmd.color("pink", "chain C")
cmd.show("cartoon")
cmd.hide("lines")
for resi in designed_residues:
string = "chain H and resi " + str(resi)
cmd.color("red",string)
cmd.show("sticks",string)
string =""
for g in designed_residues:
for i in range(1,101):
string += ("%s x1 ")%i
cmd.mset(string)
cmd.frame("1")
cmd.orient()
cmd.mview("store")
#util.mroll(1,500,1)
string=""
frame=100
for resi in designed_residues:
resi_behind = int(resi) -2
resi_ahead = int(resi) + 2
cmd.frame(frame)
string = "chain H and resi "+str(resi_behind) + "+"+ str(resi)+ "+"+str(resi_ahead)
print string
cmd.orient(string)
cmd.mview("store")
frame += 100
frames = int(os.environ["FRAMES"])
renderers = int(os.environ["RENDERERS"])
renderer_num = int(os.environ["PBS_ARRAYID"])
renderer_num = renderer_num - 1
frames_per_renderer = frames / renderers
start_frame = 1 + (renderer_num * frames_per_renderer)
end_frame = start_frame + frames_per_renderer
print "render.py: session:" + session + " name: " + name
print "Session directory:" + sessiondir
print "This is renderer: " + str(renderer_num) + " Responsible for frames: " + str(start_frame) + "-" + str(end_frame)
os.chdir(sessiondir)
cmd.load(session)
### Movie commands go here.
cmd.set("cartoon_ring_mode", 3)
cmd.mset("1 x%i" %(frames))
util.mroll(1, frames, 1, 'y')
## End movie commands.
cmd.viewport("800","800")
cmd.set("hash_max", 255)
cmd.set("cache_frames", 0)
cmd.set("ray_trace_fog", 0)
cmd.set("ray_trace_frames", 1)
cmd.set("ray_shadows", 0)
cmd.set("antialias", 0)
cmd.set("auto_zoom", 0)
cmd.mclear
for frame in range(start_frame, end_frame):
print "Rendering frame: " + str(frame)
filename = name + str("%04d" % frame) + ".png"
from pymol import cmd
num_pdb = 167
loaded_num = 0
for file_prefix in range(num_pdb):
loaded_num += 1
cmd.load(str(file_prefix + 1) + '.pdb', "mov")
cmd.show("cartoon", "")
cmd.mset("1 -%d" % loaded_num)
def testGetMovieLength(self):
cmd.fragment('gly')
self.assertEqual(cmd.get_movie_length(), 0)
cmd.mset('1x10')
self.assertEqual(cmd.get_movie_length(), 10)
self.assertEqual(cmd.get_movie_length(images=1), 0)
def reps(self, cleanup=0):
rep_list = [
"lines", "sticks", "spheres", "surface", "mesh", "dots", "ribbon",
"cartoon"
]
try:
if not cleanup:
cmd.disable()
cmd.set("suspend_updates", 1, quiet=1)
cmd.load("$PYMOL_DATA/demo/pept.pdb", "rep1")
cmd.alter("rep1///1-5+8-13/", "ss='S'")
cmd.cartoon("auto")
cmd.hide("everything", "rep1")
for a in range(2, 9):
cmd.create("rep%d" % a, "rep1")
for x, y in enumerate(rep_list, 1):
cmd.show(x, "rep%d" % y)
cmd.reset()
cmd.zoom("rep1", 24)
util.cbay("rep2")
util.cbac("rep3")
util.cbas("rep4")
util.cbab("rep5")
util.cbaw("rep6")
util.cbay("rep8")
cmd.set("suspend_updates", 0, quiet=1)
scale = 0.5
for b in range(1, 20):
cmd.set("suspend_updates", 0, quiet=1)
cmd.refresh()
cmd.set("suspend_updates", 1, quiet=1)
xt = -3.2
yt = 1.6
for a in range(1, 5):
cmd.translate([xt * scale, yt * scale, 0],
object="rep%d" % a,
camera=0)
xt = xt + 2
yt = -yt
xt = -3.2
for a in range(5, 9):
cmd.translate([xt * scale, yt * scale, 0],
object="rep%d" % a,
camera=0)
xt = xt + 2
for a in range(1, 9):
cmd.origin("rep%d" % a, object="rep%d" % a)
cmd.mset("1")
st = ' '.join(
map(
lambda x, y: "rotate angle=-3,object=rep%d,axis=%s;" %
(x, y), list(range(1, 9)),
['x', 'y', 'x', 'y', 'x', 'y', 'x', 'y']))
cmd.mdo(1, st)
cmd.set("suspend_updates", 0, quiet=1)
cmd.mplay()
cgo = []
axes = [[4.5, 0.0, 0.0], [0.0, 3.0, 0.0], [0.0, 0.0, 3.0]]
c = 1
for a in rep_list:
ext = cmd.get_extent("rep%d" % c)
pos = [(ext[0][0] + ext[1][0]) / 2,
(ext[0][1] + ext[1][1]) / 2 + 14,
(ext[0][2] + ext[1][2]) / 2]
c = c + 1
pos[0] = pos[0] - (measure_text(plain, a, axes) / 2)
wire_text(cgo, plain, pos, a, axes)
cmd.set("cgo_line_width", 1.5)
cmd.set("auto_zoom", 0)
cmd.load_cgo(cgo, 'reps')
cmd.set("auto_zoom", 1)
else:
cmd.delete("rep*")
cmd.mset()
cmd.mstop()
except:
traceback.print_exc()
def testCountFrames(self):
self.assertEqual(cmd.count_frames(), 0)
cmd.pseudoatom("m1")
self.assertEqual(cmd.count_frames(), 1)
cmd.mset("1x3")
self.assertEqual(cmd.count_frames(), 3)
"""
Generate a movie from atom-by-atom proposal PMF and placement PDB files.
Run with `run movie.py` in PyMOL
"""
iteration = 6
from pymol import cmd, movie
#cmd.mclear()
#cmd.mset('1')
cmd.set('sphere_scale', 0.02)
cmd.rewind()
cmd.delete('all')
cmd.load('geometry-%d-forward-proposal.pdb' % iteration)
cmd.hide('all')
cmd.show('spheres', 'name Ar')
cmd.spectrum(expression='b', selection='name Ar', palette='blue_white_red', minimum=0, maximum=6)
cmd.load('geometry-%d-forward-stages.pdb' % iteration)
nframes = 30
specification = ''
for i in range(15):
specification += '%d x%d ' % (i, nframes)
cmd.mset(specification)
frame = 0
for i in range(15):
movie.rock(frame, frame+nframes)
frame += nframes
def reps(self,cleanup=0):
rep_list = [ "lines","sticks","spheres","surface","mesh","dots","ribbon","cartoon" ]
try:
if not cleanup:
cmd.disable()
cmd.set("suspend_updates",1,quiet=1)
cmd.load("$PYMOL_DATA/demo/pept.pdb","rep1")
cmd.alter("rep1///1-5+8-13/","ss='S'")
cmd.cartoon("auto")
cmd.hide("everything","rep1")
for a in range(2,9):
cmd.create("rep%d"%a,"rep1")
for x, y in enumerate(rep_list, 1):
cmd.show(x, "rep%d" % y)
cmd.reset()
cmd.zoom("rep1",24)
util.cbay("rep2")
util.cbac("rep3")
util.cbas("rep4")
util.cbab("rep5")
util.cbaw("rep6")
util.cbay("rep8")
cmd.set("suspend_updates",0,quiet=1)
scale=0.5
for b in range(1,20):
cmd.set("suspend_updates",0,quiet=1)
cmd.refresh()
cmd.set("suspend_updates",1,quiet=1)
xt=-3.2
yt=1.6
for a in range(1,5):
cmd.translate([xt*scale,yt*scale,0],object="rep%d"%a,camera=0)
xt=xt+2
yt=-yt
xt=-3.2
for a in range(5,9):
cmd.translate([xt*scale,yt*scale,0],object="rep%d"%a,camera=0)
xt=xt+2
for a in range(1,9):
cmd.origin("rep%d"%a,object="rep%d"%a)
cmd.mset("1")
st = ' '.join(map(lambda x,y:"rotate angle=-3,object=rep%d,axis=%s;"%(x,y),list(range(1,9)),
['x','y','x','y','x','y','x','y']))
cmd.mdo(1,st)
cmd.set("suspend_updates",0,quiet=1)
cmd.mplay()
cgo = []
axes = [[4.5,0.0,0.0],[0.0,3.0,0.0],[0.0,0.0,3.0]]
c = 1
for a in rep_list:
ext = cmd.get_extent("rep%d"%c)
pos = [(ext[0][0]+ext[1][0])/2,
(ext[0][1]+ext[1][1])/2+14,
(ext[0][2]+ext[1][2])/2]
c = c + 1
pos[0]=pos[0]-(measure_text(plain,a,axes)/2)
wire_text(cgo,plain,pos,a,axes)
cmd.set("cgo_line_width",1.5)
cmd.set("auto_zoom",0)
cmd.load_cgo(cgo,'reps')
cmd.set("auto_zoom",1)
else:
cmd.delete("rep*")
cmd.mset()
cmd.mstop()
except:
traceback.print_exc()
def _setup_movie(self, rep):
cmd.load(self.datafile('1aon.pdb.gz'))
cmd.show_as(rep)
cmd.orient()
cmd.mset('1x100')
pymol.movie.roll(1, cmd.count_frames(), 0, 'y')
#cmd.set('surface_mode', 3)
#cmd.set('surface_color', 'white')
# QuteMol-like
cmd.bg_color('white')
cmd.set('light_count', 8)
cmd.set('spec_count', 1)
cmd.set('shininess', 10)
cmd.set('specular', 0.25)
cmd.set('ambient', 0)
cmd.set('direct', 0)
cmd.set('reflect', 1.5)
cmd.set('ray_shadow_decay_factor', 0.1)
# 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)
def show_transition(start_index=0, end_index=0):
#show the transition from the current view to the next view
global frames
global views
global cur_index
global actions
global models
if( start_index == 0 and end_index == 0 ):
if cur_index >= len(views)-1:
print "Current view is last in sequence."
return
start_index=cur_index
end_index=cur_index+1
else:
start_index = int(start_index)
end_index = int(end_index)
ftot = 0
setcommand = ""
i = start_index
for nframes in frames[start_index:end_index]:
#ftot += nframes
if models.has_key(i):
setcommand += " " + models[i] + " "
else:
setcommand += " 1 x%i" % nframes
i += 1
# cmd.mset("1 x%i" % ftot)
cmd.mset( setcommand )
start_frame = 1
#first do all actions that happen up to this point to make sure
#things look the way they should
first_action = ""
for i in range( 0, start_index ):
if actions.has_key(i):
first_action += actions[i] + ';'
#print "Executing %s from actions %d" % (actions[i],i)
#cmd.do( actions[i] )
if settings.has_key(i):
settingName, selection, startVal, endVal = settings[i]
action = "set %s, %f, %s;" % (settingName, endVal, selection)
first_action += action
#print "Executing %s from settings %d" % (action,i)
#cmd.do( action )
if fades.has_key(i):
startVisSelection, endVisSelection, sticksOnly = fades[i]
action = "set stick_transparency, 0, %s; set stick_transparency, 1, %s;" % (endVisSelection, startVisSelection)
first_action += action
#print "Executing %s from fades %d" % (action, i)
#cmd.do( action )
for i in range( start_index, end_index ):
if settings.has_key(i):
movs.animate_transition( views[i], views[i+1], frames[i], start_frame, settings[i] )
elif fades.has_key(i):
movs.animate_transition( views[i], views[i+1], frames[i], start_frame, fades[i] )
else:
movs.animate_transition( views[i], views[i+1], frames[i], start_frame )
#add an action
if start_frame == 1:
mdo_cmd = first_action
if actions.has_key(i):
mdo_cmd += actions[i]+";"
#mdo_cmd += "set_view("+str(views[i])+")"
print mdo_cmd
cmd.mdo(start_frame, mdo_cmd)
elif actions.has_key(i):
mdo_cmd = actions[i]+";set_view("+str(views[i])+")"
cmd.mdo(start_frame, mdo_cmd)
#print mdo_cmd
start_frame += frames[i]
cmd.frame(1)
cmd.mplay()
