def __call__(self):
        if self.name not in cmd.get_names('objects'):
            cmd.delete(self.callback_name)
            cmd.set_key("pgup", lambda: None)
            cmd.set_key("pgdn", lambda: None)
            return

        tmp = cmd.get_position()
        r = cpv.distance_sq(self.center, tmp)
        if (r > 0.3):  # increase this number if it is too slow
            self.update()
    def __call__(self):
        if self.name not in cmd.get_names('objects'):
            cmd.delete(self.callback_name)
            cmd.set_key("pgup", lambda: None)
            cmd.set_key("pgdn", lambda: None)
            return

        tmp = cmd.get_position()
        r = cpv.distance_sq(self.center, tmp)
        if (r > 0.3):  # increase this number if it is too slow
            self.update()
示例#3
0
 def cleanup(self):
     # save current state in global vars...
     global default_object,default_browse,static_dict
     default_object = self.object
     default_browse = self.browse
     static_dict = self.dict
     # restore key actions
     cmd.set_key('F1',None)
     cmd.set_key('F2',None)
     cmd.set_key('F3',None)
     cmd.set_key('right',cmd.forward)
     cmd.set_key('left',cmd.backward)
示例#4
0
文件: filter.py 项目: evonove/pymol
 def cleanup(self):
     # save current state in global vars...
     global default_object,default_browse,static_dict
     default_object = self.object
     default_browse = self.browse
     static_dict = self.dict
     # restore key actions
     cmd.set_key('F1',None)
     cmd.set_key('F2',None)
     cmd.set_key('F3',None)
     cmd.set_key('right',cmd.forward)
     cmd.set_key('left',cmd.backward)
示例#5
0
文件: filter.py 项目: Almad/pymol
 def cleanup(self):
     # save current state in global vars...
     global default_object, default_browse, static_dict
     default_object = self.object
     default_browse = self.browse
     static_dict = self.dict
     # restore key actions
     cmd.set_key("F1", None)
     cmd.set_key("F2", None)
     cmd.set_key("F3", None)
     cmd.set_key("right", cmd.forward)
     cmd.set_key("left", cmd.backward)
示例#6
0
    def testSetKey(self):
        if testing.PYMOL_VERSION[1] > 1.84:
            cmd.set('auto_show_classified', 0)

        cmd.fragment('gly')
        N = cmd.count_atoms()
        self.assertEqual(0, cmd.count_atoms('rep sticks | rep spheres'))
        cmd.set_key('F3', cmd.show, ('sticks', ))
        cmd._special(3, 0, 0)
        self.assertEqual(N, cmd.count_atoms('rep sticks'))
        cmd.do('set_key F3, hide sticks; show spheres')
        cmd._special(3, 0, 0)
        self.assertEqual(0, cmd.count_atoms('rep sticks'))
        self.assertEqual(N, cmd.count_atoms('rep spheres'))
示例#7
0
    def testSetKey(self):
        if testing.PYMOL_VERSION[1] > 1.84:
            cmd.set('auto_show_classified', 0)

        cmd.fragment('gly')
        N = cmd.count_atoms()
        self.assertEqual(0, cmd.count_atoms('rep sticks | rep spheres'))
        cmd.set_key('F3', cmd.show, ('sticks',))
        cmd._special(3, 0, 0)
        self.assertEqual(N, cmd.count_atoms('rep sticks'))
        cmd.do('set_key F3, hide sticks; show spheres')
        cmd._special(3, 0, 0)
        self.assertEqual(0, cmd.count_atoms('rep sticks'))
        self.assertEqual(N, cmd.count_atoms('rep spheres'))
示例#8
0
def series_resfile(color="orange"):

    # Main PDB File Name
    object = cmd.get_names()[0]
    counter = 0

    # Read Rosetta Resfile
    for fname in glob.glob('*.resfile'):
        counter += 1
        if counter == 1:
            fname_rem = fname

        cmd.copy(fname, object)
        for line in open(fname):

            # Split Resfile Line by Tab
            data = line.split('\t')

            # Only Consider Lines that Start with Residue Numbers
            if data[0].isdigit():

                # Get Revalent Data
                pos = data[0]
                chain = data[1]
                mut = data[3]

                # Generate Mutation Label
                label = mut
                label_list = list(label)
                label_list.insert(1, "%s" % (pos))
                label = ''.join(label_list)

                # PyMOL Color and Label
                cmd.color(color,
                          "resi %s and chain %s and %s" % (pos, chain, fname))
                cmd.label(
                    "resi %s and chain %s and name ca and %s" %
                    (pos, chain, fname), "\'%s\'" % (label))
            # Output Comments to the Console
            elif line[:1] == "#":
                # Remove newline feeds
                line.rstrip("\n")
                print "\n%s" % (line)

    cmd.disable('all')
    cmd.enable(fname_rem)
    cmd.orient
    cmd.set_key('pgup', move_up)
    cmd.set_key('pgdn', move_down)
示例#9
0
文件: filter.py 项目: evonove/pymol
    def __init__(self,_self=cmd):

        # initialize parent class
        
        Wizard.__init__(self,_self)

        self.update_object_menu()
        
        # restore previous state from global storage

        self.dict = static_dict
        self.object = default_object if default_object in self.avail_objects else None
        self.browse = default_browse
        self.state_dict = {}
        
        # if we don't have a current object, choose the first multi-state object
        
        if not self.object and self.avail_objects:
            self.object = self.avail_objects[0]

        # menu for
        
        self.menu['browse'] = [
            [2, 'Browse Mode',''],
            [1, 'Browse All','cmd.get_wizard().set_browse(1)'],
            [1, 'Browse Accepted','cmd.get_wizard().set_browse(2)'],
            [1, 'Browse Rejected','cmd.get_wizard().set_browse(3)'],
            [1, 'Browse Deferred','cmd.get_wizard().set_browse(4)'],
            [1, 'Browse Remaining','cmd.get_wizard().set_browse(5)'],         
            ]

        self.menu['create'] = [
            [2, 'Create Filtered Object', ''],
            [1, 'Accepted','cmd.get_wizard().create_object("Accept")'],
            [1, 'Rejected','cmd.get_wizard().create_object("Reject")'],
            [1, 'Deferred','cmd.get_wizard().create_object("Defer")'],
            ]

        self.count_object()
        self.load_state_dict()
        self.update_object_menu()
        cmd.set_key('F1',lambda s=self:s.accept())
        cmd.set_key('F2',lambda s=self:s.reject())
        cmd.set_key('F3',lambda s=self:s.defer())
        cmd.set_key('right',lambda s=self:s.forward())
        cmd.set_key('left',lambda s=self:s.backward())
示例#10
0
    def __init__(self,_self=cmd):

        # initialize parent class

        Wizard.__init__(self,_self)

        self.update_object_menu()

        # restore previous state from global storage

        self.dict = static_dict
        self.object = default_object if default_object in self.avail_objects else None
        self.browse = default_browse
        self.state_dict = {}

        # if we don't have a current object, choose the first multi-state object

        if not self.object and self.avail_objects:
            self.object = self.avail_objects[0]

        # menu for

        self.menu['browse'] = [
            [2, 'Browse Mode',''],
            [1, 'Browse All','cmd.get_wizard().set_browse(1)'],
            [1, 'Browse Accepted','cmd.get_wizard().set_browse(2)'],
            [1, 'Browse Rejected','cmd.get_wizard().set_browse(3)'],
            [1, 'Browse Deferred','cmd.get_wizard().set_browse(4)'],
            [1, 'Browse Remaining','cmd.get_wizard().set_browse(5)'],
            ]

        self.menu['create'] = [
            [2, 'Create Filtered Object', ''],
            [1, 'Accepted','cmd.get_wizard().create_object("Accept")'],
            [1, 'Rejected','cmd.get_wizard().create_object("Reject")'],
            [1, 'Deferred','cmd.get_wizard().create_object("Defer")'],
            ]

        self.count_object()
        self.load_state_dict()
        self.update_object_menu()
        cmd.set_key('F1',lambda s=self:s.accept())
        cmd.set_key('F2',lambda s=self:s.reject())
        cmd.set_key('F3',lambda s=self:s.defer())
        cmd.set_key('right',lambda s=self:s.forward())
        cmd.set_key('left',lambda s=self:s.backward())
示例#11
0
def y():
    print "translate or rotate about the y axis"
    print "F1 = translate positive"
    print "F2 = translate negative"
    print "F3 = rotate positive"
    print "F4 = rotate negative"
    cmd.set_key('F1', cmd.translate, ("[0,1,0]", "protein"))
    cmd.set_key('F2', cmd.translate, ("[0,-1,0]", "protein"))
    cmd.set_key('F3', cmd.rotate, ('y', 1, "protein"))
    cmd.set_key('F4', cmd.rotate, ('y', -1, "protein"))
示例#12
0
def z():
    print "translate or rotate about the z axis"
    print "F1 = translate positive"
    print "F2 = translate negative"
    print "F3 = rotate positive"
    print "F4 = rotate negative"
    cmd.set_key('F1', cmd.translate, ("[0,0,1]", "protein"))
    cmd.set_key('F2', cmd.translate, ("[0,0,-1]", "protein"))
    cmd.set_key('F3', cmd.rotate, ('z', 1, "protein"))
    cmd.set_key('F4', cmd.rotate, ('z', -1, "protein"))
    cmd.clip("atoms", 5, "all")
    cmd.set("depth_cue", 0)
示例#13
0
文件: filter.py 项目: Almad/pymol
    def __init__(self, _self=cmd):

        # initialize parent class

        Wizard.__init__(self, _self)

        # restore previous state from global storage

        self.dict = static_dict
        self.object = default_object
        self.browse = default_browse
        self.avail_objects = []
        self.state_dict = {}

        # if we don't have a current object, choose the first multi-state object

        if self.object == None:
            for a in cmd.get_names("objects"):
                if cmd.get_type(a) == "object:molecule":
                    if cmd.count_states(a) > 1:
                        self.object = a
                        break

        # menu for

        self.menu["browse"] = [
            [2, "Browse Mode", ""],
            [1, "Browse All", "cmd.get_wizard().set_browse(1)"],
            [1, "Browse Accepted", "cmd.get_wizard().set_browse(2)"],
            [1, "Browse Rejected", "cmd.get_wizard().set_browse(3)"],
            [1, "Browse Deferred", "cmd.get_wizard().set_browse(4)"],
            [1, "Browse Remaining", "cmd.get_wizard().set_browse(5)"],
        ]

        self.count_object()
        self.load_state_dict()
        self.update_object_menu()
        cmd.set_key("F1", lambda s=self: s.accept())
        cmd.set_key("F2", lambda s=self: s.reject())
        cmd.set_key("F3", lambda s=self: s.defer())
        cmd.set_key("right", lambda s=self: s.forward())
        cmd.set_key("left", lambda s=self: s.backward())
示例#14
0
文件: filter.py 项目: jchodera/pymol
    def __init__(self, _self=cmd):

        # initialize parent class

        Wizard.__init__(self, _self)

        # restore previous state from global storage

        self.dict = static_dict
        self.object = default_object
        self.browse = default_browse
        self.avail_objects = []
        self.state_dict = {}

        # if we don't have a current object, choose the first multi-state object

        if self.object == None:
            for a in cmd.get_names('objects'):
                if cmd.get_type(a) == 'object:molecule':
                    if cmd.count_states(a) > 1:
                        self.object = a
                        break

        # menu for

        self.menu['browse'] = [
            [2, 'Browse Mode', ''],
            [1, 'Browse All', 'cmd.get_wizard().set_browse(1)'],
            [1, 'Browse Accepted', 'cmd.get_wizard().set_browse(2)'],
            [1, 'Browse Rejected', 'cmd.get_wizard().set_browse(3)'],
            [1, 'Browse Deferred', 'cmd.get_wizard().set_browse(4)'],
            [1, 'Browse Remaining', 'cmd.get_wizard().set_browse(5)'],
        ]

        self.count_object()
        self.load_state_dict()
        self.update_object_menu()
        cmd.set_key('F1', lambda s=self: s.accept())
        cmd.set_key('F2', lambda s=self: s.reject())
        cmd.set_key('F3', lambda s=self: s.defer())
        cmd.set_key('right', lambda s=self: s.forward())
        cmd.set_key('left', lambda s=self: s.backward())
    def __init__(self, map_name, level, radius, name, sym_source):
        self.level = level
        self.radius = radius
        self.map_name = map_name
        self.name = name
        self.center_name = cmd.get_unused_name('_center')
        self.callback_name = cmd.get_unused_name('_cb')

        cmd.set("auto_zoom", 0)
        cmd.pseudoatom(self.center_name)
        cmd.hide("everything", self.center_name)

        symmetry = cmd.get_symmetry(sym_source or map_name)
        if symmetry:
            cmd.set("map_auto_expand_sym", 1)
            cmd.set_symmetry(self.center_name, *symmetry)

        cmd.set_key("pgup", self.contour_plus)
        cmd.set_key("pgdn", self.contour_minus)

        self.update()
    def __init__(self, map_name, level, radius, name, sym_source):
        self.level = level
        self.radius = radius
        self.map_name = map_name
        self.name = name
        self.center_name = cmd.get_unused_name('_center')
        self.callback_name = cmd.get_unused_name('_cb')

        cmd.set("auto_zoom", 0)
        cmd.pseudoatom(self.center_name)
        cmd.hide("everything", self.center_name)

        symmetry = cmd.get_symmetry(sym_source or map_name)
        if symmetry:
            cmd.set("map_auto_expand_sym", 1)
            cmd.set_symmetry(self.center_name, *symmetry)

        cmd.set_key("pgup", self.contour_plus)
        cmd.set_key("pgdn", self.contour_minus)

        self.update()
示例#17
0
	all_objs = cmd.get_names("objects",enabled_only=0)
	for obj in enabled_objs:
		cmd.disable(obj)
		last_obj=obj
		for i in range(0,len(all_objs)):
			if all_objs[i] == obj:
				if i+1 >= len(all_objs):
					cmd.enable( all_objs[0] )
				else:
					cmd.enable( all_objs[i+1] )
	cmd.orient
def move_up():
	enabled_objs = cmd.get_names("objects",enabled_only=1)
        all_objs = cmd.get_names("objects",enabled_only=0)
        for obj in enabled_objs:
                cmd.disable(obj)
                last_obj=obj
                for i in range(0,len(all_objs)):
                        if all_objs[i] == obj:
                                if i-1 < 0:
                                        cmd.enable( all_objs[-1] )
                                else:
                                        cmd.enable( all_objs[i-1] )
	cmd.orient
cmd.set_key('pgup', move_up)
cmd.set_key('pgdn', move_down)
#cmd.set_key('up', move_up)
#cmd.set_key('down', move_down)
#cmd.set_key('left', move_up)
#cmd.set_key('right', move_down)
示例#18
0
#

from glob import glob

import threading
import time

from pymol import cmd
import sys, os, os.path
import pymol

ent_dir = "pdb"

pymol.run = 1

cmd.set_key('F1', lambda p=pymol: (setattr(p, 'run', 0)))
cmd.set_key('F2', lambda p=pymol: (setattr(p, 'run', 1)))


def load():
    r = 0
    rep = [
        "simple", "technical", "ligands", "ligand_sites", "ligand_sites_trans",
        "ligand_sites_mesh", "pretty", "publication"
    ]
    list = glob("pdb/*/*")
    #   while list[0]!="pdb/f8/pdb1f8u":
    #      list.pop(0)
    for file in list:
        print file
        cmd.delete('pdb')
示例#19
0
# -c

from pymol import cmd

print "BEGIN-LOG"

print cmd.set_key('F1',lambda :cmd.turn('x',10))
print cmd.set_key('F12',lambda :cmd.turn('x',10))

print cmd.set_key('left',lambda :cmd.turn('x',10))
print cmd.set_key('right',lambda :cmd.turn('x',10))
print cmd.set_key('pgup',lambda :cmd.turn('x',10))
print cmd.set_key('pgdn',lambda :cmd.turn('x',10))
print cmd.set_key('home',lambda :cmd.turn('x',10))
print cmd.set_key('insert',lambda :cmd.turn('x',10))

print cmd.set_key('ALT-A',lambda :cmd.turn('y',10))

print cmd.set_key('CTRL-C',lambda :cmd.turn('z',10))

print cmd.set_key('SHFT-F1', lambda :cmd.turn('z',10))

print cmd.set_key('ALT-F1', lambda :cmd.turn('y',10))

print cmd.set_key('CTRL-F8', lambda :cmd.move('x',1))


print "END-LOG"


示例#20
0
def spawnPDBDirCycler(target_dir='.',lite=False):
    if lite: viewing.cycler = PDBDirCyclerLite(target_dir)
    else: viewing.cycler = PDBDirCycler(target_dir)
    cmd.set_key('left',prev_pdb)
    cmd.set_key('right',next_pdb)
示例#21
0
    button_list.remove(butt)
    button_list.remove(butt)	
    cmd.util.cbag ('all')

  elif butt != button_list[0]:
    button_list.remove(button_list[0])
    cmd.util.cbag ('all')
    curSel = col2

  else:
    cmd.util.cbag ('all')
    curSel = col2

# colouring selection with specified colour scheme
  cmd.set_color('siff', curSel )
  cmd.color('siff', InteractionButton[InteractionName.index(butt)]+'_'+butt )
  butt=[]

cmd.extend('read_siftp', read_siftp)

cmd.set_key( 'F1' , add_color, (any_i, 'any_i' ) )
cmd.set_key( 'F2' , add_color, (backb, 'backb' ) )
cmd.set_key( 'F3' , add_color, (sidec, 'sidec' ) )
cmd.set_key( 'F4' , add_color, (polar, 'polar' ) )
cmd.set_key( 'F5' , add_color, (hphob, 'hphob' ) )
cmd.set_key( 'F6' , add_color, (hbacc, 'hbacc' ) )
cmd.set_key( 'F7' , add_color, (hbdon, 'hbdon' ) )
cmd.set_key( 'F8' , add_color, (aroma, 'aroma' ) )
cmd.set_key( 'F9' , add_color, (charg, 'charg' ) )

示例#22
0
def spawnObjectCycler():
    viewing.cycler = ObjectCycler()
    cmd.set_key('left', prev_pdb)
    cmd.set_key('right', next_pdb)
def __init__(self):
    #MAIN
    self.menuBar.addcascademenu('Plugin','SuperSym')
    #DEFAULT SET BUILD
    self.menuBar.addmenuitem('SuperSym', 'command', 'Default Symmetry Partner Set',
                             label = 'Default Symmetry Partner Set', 
                             command = lambda s = self: symDialog(s, 0))
    #UNIT CELL BUILD
    self.menuBar.addmenuitem('SuperSym', 'command', 'Draw Unit Cell',
                             label = 'Draw Unit Cell', 
                             command = lambda s = self: cellDialog(s))
    #SYM SUBMENU
    self.menuBar.addcascademenu('SuperSym', 'Build Symmetry Partners')

    self.menuBar.addmenuitem('Build Symmetry Partners', 'command', 'Cell [0,0,0] (default)', 
                             label = 'Cell [0,0,0] (default)', 
                             command = lambda s = self: symDialog(s, 0))

    self.menuBar.addmenuitem('Build Symmetry Partners', 'command', 'Cell [x,y,z] (custom)',
                             label = 'Cell [x,y,z] (custom)', 
                             command = lambda s = self: symDialog(s, 1))

    self.menuBar.addmenuitem('Build Symmetry Partners', 'command', '2x2x2 Block',
                             label = '2x2x2 Block', 
                             command = lambda s = self: symDialog(s, 2))

    self.menuBar.addmenuitem('Build Symmetry Partners', 'command', '3x3x3 Block',
                             label = '3x3x3 Block', 
                             command = lambda s = self: symDialog(s, 3))

    self.menuBar.addmenuitem('Build Symmetry Partners', 'command', 'By Partner',
                             label = 'By Partner', 
                             command = lambda s = self: symDialog(s, 4))
    #COLOR SUBMENU
    self.menuBar.addcascademenu('SuperSym', 'Coloring')

    self.menuBar.addmenuitem('Coloring', 'command', 'Default Rainbow',
                             label = 'Default Rainbow', 
                             command = lambda s = self: colorDialog(s, 0))

    self.menuBar.addmenuitem('Coloring', 'command', 'Select color for each operation',
                             label = 'Select color for each operation', 
                             command = lambda s = self: colorDialog(s, 1))

    self.menuBar.addmenuitem('Coloring', 'command', 'Select one color for custom set of operations',
                             label = 'Select one color for custom set of operations', 
                             command = lambda s = self: colorDialog(s, 2))
    #GRAPHICS SUBMENU
    self.menuBar.addcascademenu('SuperSym', 'Graphics')

    self.menuBar.addmenuitem('Graphics', 'command', 'Lines',
                             label = 'Lines', 
                             command = lambda s = self: graphicsDialog(s, 0))

    self.menuBar.addmenuitem('Graphics', 'command', 'Ribbon',
                             label = 'Ribbon', 
                             command = lambda s = self: graphicsDialog(s, 1))
    self.menuBar.addmenuitem('Graphics', 'command', 'Cartoon',
                             label = 'Cartoon',
                             command = lambda s = self: graphicsDialog(s, 2))
    self.menuBar.addmenuitem('Graphics', 'command', 'Sphere Surface (best for printing)',
                             label = 'Sphere Surface (best for printing)', 
                             command = lambda s = self: graphicsDialog(s, 3))

    self.menuBar.addmenuitem('Graphics', 'command', 'Surface (high load render)',
                             label = 'Surface (high load render)', 
                             command = lambda s = self: graphicsDialog(s, 4))
    #SYM AXES SUBMENU
    self.menuBar.addcascademenu('SuperSym', 'Symmetry Axes')

    self.menuBar.addmenuitem('Symmetry Axes', 'command', 'Build Axes',
                             label = 'Build Axes', 
                             command = lambda s = self: axesDialog(s))
    #ADD OTHER SYMMETRY AXES OPTION HERE
    self.menuBar.addmenuitem('SuperSym', 'command', 'Move symmetry partners',
                             label = 'Move symmetry partners',
                             command = lambda s = self: cellShiftInfo(s))
    self.menuBar.addmenuitem('SuperSym', 'command', 'About',
                             label = 'About',
                             command = lambda s = self: aboutInfo(s))
    self.menuBar.addmenuitem('SuperSym', 'command', 'Help',
                             label = 'Help',
                             command = lambda s = self: helpInfo(s))
    cmd.cell_shift = cell_shift
    cmd.get_operations = get_operations
    cmd.get_matrix = get_orthogonalization_matrix
    cmd.symset = symset
    cmd.cell_shift_helper = cell_shift_helper
    cmd.set_key("ALT-6", cell_shift_proxyX1)
    cmd.set_key("ALT-4", cell_shift_proxyX2) 
    cmd.set_key("ALT-8", cell_shift_proxyY1) 
    cmd.set_key("ALT-2", cell_shift_proxyY2) 
    cmd.set_key("ALT-5", cell_shift_proxyZ1) 
    cmd.set_key("ALT-1", cell_shift_proxyZ2)
示例#24
0
def __init__(self):
    #MAIN
    self.menuBar.addcascademenu('Plugin', 'SuperSym')
    #DEFAULT SET BUILD
    self.menuBar.addmenuitem('SuperSym',
                             'command',
                             'Default Symmetry Partner Set',
                             label='Default Symmetry Partner Set',
                             command=lambda s=self: symDialog(s, 0))
    #UNIT CELL BUILD
    self.menuBar.addmenuitem('SuperSym',
                             'command',
                             'Draw Unit Cell',
                             label='Draw Unit Cell',
                             command=lambda s=self: cellDialog(s))
    #SYM SUBMENU
    self.menuBar.addcascademenu('SuperSym', 'Build Symmetry Partners')

    self.menuBar.addmenuitem('Build Symmetry Partners',
                             'command',
                             'Cell [0,0,0] (default)',
                             label='Cell [0,0,0] (default)',
                             command=lambda s=self: symDialog(s, 0))

    self.menuBar.addmenuitem('Build Symmetry Partners',
                             'command',
                             'Cell [x,y,z] (custom)',
                             label='Cell [x,y,z] (custom)',
                             command=lambda s=self: symDialog(s, 1))

    self.menuBar.addmenuitem('Build Symmetry Partners',
                             'command',
                             '2x2x2 Block',
                             label='2x2x2 Block',
                             command=lambda s=self: symDialog(s, 2))

    self.menuBar.addmenuitem('Build Symmetry Partners',
                             'command',
                             '3x3x3 Block',
                             label='3x3x3 Block',
                             command=lambda s=self: symDialog(s, 3))

    self.menuBar.addmenuitem('Build Symmetry Partners',
                             'command',
                             'By Partner',
                             label='By Partner',
                             command=lambda s=self: symDialog(s, 4))
    #COLOR SUBMENU
    self.menuBar.addcascademenu('SuperSym', 'Coloring')

    self.menuBar.addmenuitem('Coloring',
                             'command',
                             'Default Rainbow',
                             label='Default Rainbow',
                             command=lambda s=self: colorDialog(s, 0))

    self.menuBar.addmenuitem('Coloring',
                             'command',
                             'Select color for each operation',
                             label='Select color for each operation',
                             command=lambda s=self: colorDialog(s, 1))

    self.menuBar.addmenuitem(
        'Coloring',
        'command',
        'Select one color for custom set of operations',
        label='Select one color for custom set of operations',
        command=lambda s=self: colorDialog(s, 2))
    #GRAPHICS SUBMENU
    self.menuBar.addcascademenu('SuperSym', 'Graphics')

    self.menuBar.addmenuitem('Graphics',
                             'command',
                             'Lines',
                             label='Lines',
                             command=lambda s=self: graphicsDialog(s, 0))

    self.menuBar.addmenuitem('Graphics',
                             'command',
                             'Ribbon',
                             label='Ribbon',
                             command=lambda s=self: graphicsDialog(s, 1))
    self.menuBar.addmenuitem('Graphics',
                             'command',
                             'Cartoon',
                             label='Cartoon',
                             command=lambda s=self: graphicsDialog(s, 2))
    self.menuBar.addmenuitem('Graphics',
                             'command',
                             'Sphere Surface (best for printing)',
                             label='Sphere Surface (best for printing)',
                             command=lambda s=self: graphicsDialog(s, 3))

    self.menuBar.addmenuitem('Graphics',
                             'command',
                             'Surface (high load render)',
                             label='Surface (high load render)',
                             command=lambda s=self: graphicsDialog(s, 4))
    #SYM AXES SUBMENU
    self.menuBar.addcascademenu('SuperSym', 'Symmetry Axes')

    self.menuBar.addmenuitem('Symmetry Axes',
                             'command',
                             'Build Axes',
                             label='Build Axes',
                             command=lambda s=self: axesDialog(s))
    #ADD OTHER SYMMETRY AXES OPTION HERE
    self.menuBar.addmenuitem('SuperSym',
                             'command',
                             'Move symmetry partners',
                             label='Move symmetry partners',
                             command=lambda s=self: cellShiftInfo(s))
    self.menuBar.addmenuitem('SuperSym',
                             'command',
                             'About',
                             label='About',
                             command=lambda s=self: aboutInfo(s))
    self.menuBar.addmenuitem('SuperSym',
                             'command',
                             'Help',
                             label='Help',
                             command=lambda s=self: helpInfo(s))
    cmd.cell_shift = cell_shift
    cmd.get_operations = get_operations
    cmd.get_matrix = get_orthogonalization_matrix
    cmd.symset = symset
    cmd.cell_shift_helper = cell_shift_helper
    cmd.set_key("ALT-6", cell_shift_proxyX1)
    cmd.set_key("ALT-4", cell_shift_proxyX2)
    cmd.set_key("ALT-8", cell_shift_proxyY1)
    cmd.set_key("ALT-2", cell_shift_proxyY2)
    cmd.set_key("ALT-5", cell_shift_proxyZ1)
    cmd.set_key("ALT-1", cell_shift_proxyZ2)
示例#25
0
def spawnPDBListFileCycler(list_file,lite=False):
    if lite: viewing.cycler = PDBListFileCyclerLite(list_file)
    else: viewing.cycler = PDBListFileCycler(list_file)
    cmd.set_key('left',prev_pdb)
    cmd.set_key('right',next_pdb)
示例#26
0
def spawnObjectCycler():
    viewing.cycler = ObjectCycler()
    cmd.set_key('left',prev_pdb)
    cmd.set_key('right',next_pdb)
示例#27
0
def switch():
    cmd.orient
    cmd.set_key('pgup', move_up)
    cmd.set_key('pgdn', move_down)
示例#28
0
    print('p - prepare seq for printing')
    print('rp - rna present, object names only click to get compact legend')
    print('rp17')
    print('get_pdb')
    print('rna_cartoon')
    print('rs')
    print('rcomp')
    print('color_obj')
    print('color_rbw')
    print('aa')
    print("""spli - color snRNAs of the spliceosome:
    green: U2,  blue: U5, red:U6, orange:U2""")
    print('RNA_PDB_TOOLS env variable used: ' + RNA_PDB_TOOLS)

    #cmd.set_key('CTRL-S', cmd.save, ['/home/magnus/Desktop/tmp.pse'])
    cmd.set_key('CTRL-S', sav_tmp)
    cmd.set_key('CTRL-Z', load_tmp)  # ostatni wrzucam tutaj
    #cmd.load, ['/home/magnus/Desktop/tmp.pse'])
    # main code #

    cmd.extend('rp17', rp17)
    cmd.extend('rp17csrv', rp17csrv)

    cmd.extend('rp', rp)
    cmd.extend('p', p)
    cmd.extend('pdb', pdb)
    cmd.extend('seq', seq)
    cmd.extend('rna_cartoon', rna_cartoon)
    cmd.extend('rs', rs)
    cmd.extend('ino', ino)
    cmd.extend('rcomp', rcomp)
示例#29
0
def spawnPDBDirCycler(target_dir='.', lite=False):
    if lite: viewing.cycler = PDBDirCyclerLite(target_dir)
    else: viewing.cycler = PDBDirCycler(target_dir)
    cmd.set_key('left', prev_pdb)
    cmd.set_key('right', next_pdb)
示例#30
0
def spawnPDBListFileCycler(list_file, lite=False):
    if lite: viewing.cycler = PDBListFileCyclerLite(list_file)
    else: viewing.cycler = PDBListFileCycler(list_file)
    cmd.set_key('left', prev_pdb)
    cmd.set_key('right', next_pdb)
示例#31
0
#  Copyright 2020 Carlos Eduardo Sequeiros Borja <*****@*****.**>

from pymol import cmd

cmd.set_key("CTRL-W", cmd.reinitialize)
cmd.set_key("CTRL-D", cmd.quit)
示例#32
0
    all_objs = cmd.get_names("objects",enabled_only=0)
    for i in cmd.get_object_list(): 
        cmd.hide("everything", i)
        cmd.show("cartoon", i)
        cmd.set("cartoon_flat_sheets", 0)
        #cmd.show("surface", i)
        cmd.show("lines", i)
        if i != 'peptide_on_target-keep':
            cmd.show("stick", "resname CYS and not name c+n+o")   
        cmd.hide("everything", "symbol H")     
    #cmd.set("surface_cavity_mode", 1)
    #cmd.set("surface_type",2)

def hide_chain_b():
    cmd.hide("everything","chain b")
    cmd.hide("everything","resn hoh")

    
    cmd.orient
cmd.set_key('pgup', move_up)
cmd.set_key('pgdn', move_down)
#
# PG add
#cmd.set_key( 'F1' , make_it_blue, [ "object1" ] )
cmd.set_key('right',gv)#hide_chain_b)
cmd.set_key('left',align_structure)
#cmd.set_key('up', move_up)
#cmd.set_key('down', gv)
#cmd.set_key('left', move_up)
#cmd.set_key('right', move_down)
        pdb_list.append(line[:5])
# remove header
#pdb_list = pdb_list[1:]
print(len(pdb_list) - 1)
#print(pdb_list[0])


def load_next():
    global i
    i += 1
    if (i < len(pdb_list)):
        print("i=%s\tentry=%s" % (str(i), pdb_list[i]))
        show_chain_in_PDB(pdb_list[i])
    else:
        print("fin")


cmd.set_key('right', load_next)


def show_chain_in_PDB(entry):
    PDB = entry[:4]
    chain = entry[-1:]
    cmd.reinitialize('everything')
    cmd.do('@~/.pymolrc')
    cmd.set("bg_rgb", "white")
    cmd.run("%s/strands_%s.py" % (PyMOL_script_dir, PDB))
    cmd.show("cartoon", "all")
    cmd.set("cartoon_transparency", .85, PDB)
    cmd.set("cartoon_transparency", 0.05, "%s_barrel" % PDB)
    print('  findN')
    print('  savt - save_transformed <object>, <file>')
    print(' select br. all within 20 of (sele) #within with aa')
    #print('  spl - color snRNAs of the spliceosome:'
    #    green: U2,  blue: U5, red:U6, orange:U2""")
    print('\_ RNA_TOOLS_PATH env variable used: ' + RNA_TOOLS_PATH)


try:
    from pymol import cmd
except ImportError:
    print("PyMOL Python lib is missing")
else:
    quickref()
    #cmd.set_key('CTRL-S', cmd.save, ['/home/magnus/Desktop/tmp.pse'])
    cmd.set_key('CTRL-S', sav_tmp)
    cmd.set_key('CTRL-Z', load_tmp)  # ostatni wrzucam tutaj
    #cmd.load, ['/home/magnus/Desktop/tmp.pse'])
    # main code #

    cmd.extend('quickref', quickref)
    cmd.extend('qr', quickref)
    cmd.extend('rg2', g2)
    cmd.extend('x', g2)

    cmd.extend('rp', rp)
    cmd.extend('p', p)
    cmd.extend('pdb', pdb)
    cmd.extend('seq', seq)
    cmd.extend('rseq', seq)
    cmd.extend('rna_cartoon', rna_cartoon)
# -c

from pymol import cmd

print "BEGIN-LOG"

print cmd.set_key('F1', lambda: cmd.turn('x', 10))
print cmd.set_key('F12', lambda: cmd.turn('x', 10))

print cmd.set_key('left', lambda: cmd.turn('x', 10))
print cmd.set_key('right', lambda: cmd.turn('x', 10))
print cmd.set_key('pgup', lambda: cmd.turn('x', 10))
print cmd.set_key('pgdn', lambda: cmd.turn('x', 10))
print cmd.set_key('home', lambda: cmd.turn('x', 10))
print cmd.set_key('insert', lambda: cmd.turn('x', 10))

print cmd.set_key('ALT-A', lambda: cmd.turn('y', 10))

print cmd.set_key('CTRL-C', lambda: cmd.turn('z', 10))

print cmd.set_key('SHFT-F1', lambda: cmd.turn('z', 10))

print cmd.set_key('ALT-F1', lambda: cmd.turn('y', 10))

print cmd.set_key('CTRL-F8', lambda: cmd.move('x', 1))

print "END-LOG"
示例#36
0
文件: B01.py 项目: Almad/pymol
import time
import math
from pymol import cmd
import sys, os, os.path

last1 = ""
last2 = ""
ent_dir = "pdb"


def adjust(delay):
    global cycle_time
    cycle_time = delay


cmd.set_key("F1", adjust, (0,))
cmd.set_key("F2", adjust, (1,))
cmd.set_key("F3", adjust, (2,))
cmd.set_key("F4", adjust, (3,))
cmd.set_key("F5", adjust, (7,))
cmd.set_key("F6", adjust, (10,))
cmd.set_key("F7", adjust, (15,))
cmd.set_key("F8", adjust, (30,))
cmd.set_key("F9", adjust, (60,))
cmd.set_key("F10", adjust, (120,))

cycle_time = 2.0

cmd.set("line_width", "2")
cmd.set("cartoon_tube_radius", "0.2")
cmd.set("cartoon_side_chain_helper")
 
def move_down():
        enabled_objs = cmd.get_names("object",enabled_only=1)
        all_objs = cmd.get_names("object",enabled_only=0)
        for obj in enabled_objs:
                cmd.disable(obj)
                last_obj=obj
                for i in range(0,len(all_objs)):
                        if all_objs[i] == obj:
                                if i+1 >= len(all_objs):
                                        cmd.enable( all_objs[0] )
                                else:
                                        cmd.enable( all_objs[i+1] )
        cmd.orient
def move_up():
        enabled_objs = cmd.get_names("object",enabled_only=1)
        all_objs = cmd.get_names("object",enabled_only=0)
        for obj in enabled_objs:
                cmd.disable(obj)
                last_obj=obj
                for i in range(0,len(all_objs)):
                        if all_objs[i] == obj:
                                if i-1 < 0:
                                        cmd.enable( all_objs[-1] )
                                else:
                                        cmd.enable( all_objs[i-1] )
        cmd.orient
 
cmd.set_key('left', move_up)
cmd.set_key('right', move_down)
from pymol import cmd
 
# Define aliases for mapping in [x,y,z] rotations and translations into a single Powermate
# dial.  Toggling between the three is possible if you then assign these to special keys.
 
# Functions for x,y,z rotations and translations using Powermate dial
# Program F1 and F2 for Rotate Right and Rotate Left
# Program F3 and F4 for Click & Rotate Right and Click & Rotate Left
# Program F5 for  Click  (to toggle between dialsets)
 
# dialset = 2
 
def dialx(): \
    global dialset \
    dialset = 1 \
    cmd.set_key ('F1', cmd.turn,('x',-2.0)) \
    cmd.set_key ('F2', cmd.turn,('x',2.0)) \
    cmd.set_key ('F3', cmd.move,('x',-0.5)) \
    cmd.set_key ('F4', cmd.move,('x',0.5)) \
    print "dialset ", dialset, " [ X ]\n" \
    return dialset
 
def dialy(): \
    global dialset \
    dialset = 2 \
    cmd.set_key ('F1', cmd.turn,('y',-2.0)) \
    cmd.set_key ('F2', cmd.turn,('y',2.0)) \
    cmd.set_key ('F3', cmd.move,('y',-0.5)) \
    cmd.set_key ('F4', cmd.move,('y',0.5)) \
    print "dialset ", dialset, " [ Y ]\n" \
    return dialset
示例#39
0
import time
import math
from pymol import cmd
import sys, os, os.path

last1 = ''
last2 = ''
ent_dir = "pdb"


def adjust(delay):
    global cycle_time
    cycle_time = delay


cmd.set_key("F1", adjust, (0, ))
cmd.set_key("F2", adjust, (1, ))
cmd.set_key("F3", adjust, (2, ))
cmd.set_key("F4", adjust, (3, ))
cmd.set_key("F5", adjust, (7, ))
cmd.set_key("F6", adjust, (10, ))
cmd.set_key("F7", adjust, (15, ))
cmd.set_key("F8", adjust, (30, ))
cmd.set_key("F9", adjust, (60, ))
cmd.set_key("F10", adjust, (120, ))

cycle_time = 2.0

cmd.set("line_width", "2")
cmd.set("cartoon_tube_radius", "0.2")
cmd.set("cartoon_side_chain_helper")
示例#40
0
cmd.extend('hot_spot_hide', hot_spot_hide)


def interface_analyse_multi(dist=10):
    cmd.disable('all')
    all_objects = cmd.get_object_list()
    for obj in all_objects:
        print 'analysing', obj
        interface_analyser(obj, dist, animate=False)
        cmd.disable(obj)
        cmd.disable(obj + '_h.bonds')
    cmd.do('order *, yes')
    cmd.zoom(all_objects[0], animate=-1)
    cmd.orient(all_objects[0], animate=-1)
    cmd.enable(all_objects[0])
    cmd.enable(all_objects[0] + '_h.bonds')


cmd.extend('interface_analyse_multi', interface_analyse_multi)


def test_function():
    print 'git is working'
    pass


cmd.extend('test_function', test_function)

cmd.set_key('ALT-H', hot_spot_spheres)
cmd.set_key('ALT-G', hot_spot_hide)
示例#41
0
def inner_lddt(interface=False):

    # Save the camera
    save_view = cmd.get_view(output=1, quiet=1)

    pdbname = cmd.get_object_list()[0]

    file_path = os.path.join(my_lddt_path, pdbname + ".npz")

    if ( not os.path.exists(file_path) ):
        print("Could not find npz file: %s"%file_path)
        return

    dat = np.load(file_path)

    ### Stuff from Nao

    digitizations = [-20.0, -15.0, -10.0, -4.0, -2.0, -1.0, -0.5, 0.5, 1.0, 2.0, 4.0, 10.0, 15.0, 20.0]
    masses = [digitizations[0]]+[(digitizations[i]+digitizations[i+1])/2 for i in range(len(digitizations)-1)]+[digitizations[-1]]

    def get_lddt(estogram, mask, center=7, weights=[1,1,1,1]):  
        # Remove diagonal from the mask.
        mask = np.multiply(mask, np.ones(mask.shape)-np.eye(mask.shape[0]))
        # Masking the estogram except for the last cahnnel
        masked = np.transpose(np.multiply(np.transpose(estogram, [2,0,1]), mask), [1,2,0])

        p0 = np.sum(masked[:,:,center], axis=-1)
        p1 = np.sum(masked[:,:,center-1]+masked[:,:,center+1], axis=-1)
        p2 = np.sum(masked[:,:,center-2]+masked[:,:,center+2], axis=-1)
        p3 = np.sum(masked[:,:,center-3]+masked[:,:,center+3], axis=-1)
        p4 = np.sum(mask, axis=-1)

        p4[p4==0] = 1
        # Only work on parts where interaction happen
        output = np.divide((weights[0]*p0 + weights[1]*(p0+p1) + weights[2]*(p0+p1+p2) + weights[3]*(p0+p1+p2+p3))/np.sum(weights), p4)
        return output

    #####

    # if interface, mask out the binder and the target to get individual lddts
    if ( interface ):

        blen = len(cmd.get_coords('name CA and chain A', 1))

        mask2 = np.zeros(dat['mask'].shape)
        mask2[:blen, blen:] = 1
        mask2[blen:, :blen] = 1

        my_lddt = get_lddt(dat['estogram'].transpose([1,2,0]), np.multiply(dat['mask'], mask2))

    else:

        my_lddt = get_lddt(dat['estogram'].transpose([1,2,0]), dat['mask'])


    print("========== Mean LDDT: %.2f"%np.mean(my_lddt))


    # colorspace for lddt visualization
    max_color = 121
    min_color = 0

    # interpolate on RGB so we don't see every color in between
    # set saturation to 0.5 so that we can distinguish from cylinders
    max_rgb = colorsys.hsv_to_rgb(max_color/360, 0.5, 1)
    min_rgb = colorsys.hsv_to_rgb(min_color/360, 0.5, 1)

    max_lddt = 1.0
    min_lddt = 0.5

    # color each residue the corresponding lddt color
    for seqpos in range(1, len(dat['mask'])):
        this_lddt = my_lddt[seqpos-1]
     
        r = np.interp(this_lddt, [min_lddt, max_lddt], [min_rgb[0], max_rgb[0]]) * 255
        g = np.interp(this_lddt, [min_lddt, max_lddt], [min_rgb[1], max_rgb[1]]) * 255
        b = np.interp(this_lddt, [min_lddt, max_lddt], [min_rgb[2], max_rgb[2]]) * 255

        color = "0x%02x%02x%02x"%(int(r), int(g), int(b))

        colorCPK("resi %i"%seqpos, color)

        # cmd.color(color, "resi %i"%seqpos,)


    # get 1 indexed ca positions
    cas = np.r_[ [[0, 0, 0]], cmd.get_coords('name CA', 1)]

    # max radius of cylinders (A)
    max_rad = 0.25

    # standard cylinder drawing function. color in HSV
    def get_cyl(start, end, rad_frac=1.0, color=[360, 0, 1]):

        rgb = colorsys.hsv_to_rgb(color[0]/360, color[1], color[2])

        radius = max_rad * rad_frac
        cyl = [
            # Tail of cylinder
            cgo.CYLINDER, start[0], start[1], start[2]
            , end[0], end[1], end[2]
            , radius, rgb[0], rgb[1], rgb[2], rgb[0], rgb[1], rgb[2]  # Radius and RGB for each cylinder tail
        ]

        return cyl


    def obj_exists(sele):
       return sele in cmd.get_names("objects")


    # clear out the old ones if we ran this twice
    for name in cmd.get_names("objects"):
        if (name.startswith("esto_res")):
            cmd.delete(name)


    estogram = np.transpose(dat['estogram'], [1, 2, 0])

    # parameters for cylinder colors
    # Since the lddt calculation maxes out at 4, we do so too
    # Also, fade near-0 to white so that we don't see sharp edges
    close_range_colors = [58, 0]
    far_range_colors = [167, 296]
    max_range = 4
    white_fade = 0.2

    # interpolate in hue space so that we do see all colors in-between
    def dist_to_color(dist):
        dist = np.clip(dist, -max_range, max_range)
        # dist = 2
        if ( dist < 0 ):
            bounds = close_range_colors
            dist = - dist
        else:
            bounds = far_range_colors

        hue = np.interp(dist, [0, max_range], bounds)
        sat = np.interp(dist, [0, white_fade], [0, 1])

        return [hue, sat, 1]

    # Mask is how likely the model things two residues are within 15A of each other
    # Don't draw cylinders for super distant residues
    min_mask = 0.1

    # actually draw the cylinders
    for seqpos in range(1, len(cas)):

        # pull out the estogram and mask for this position
        esto = estogram[seqpos-1] # shape (N x 15)
        mask = dat['mask'][seqpos-1] # shape (N)

        this_cgo = []

        for other in range(1, len(cas)):
            mask_edge = mask[other-1]
            if ( mask_edge < min_mask ):
                continue

            # estogram is a histogram of distances
            # this method comes directly from nao and takes the "center_of_mass" of that histogram
            esto_dist = np.sum(esto[other-1]*masses)

            color = dist_to_color(esto_dist)

            this_cgo += get_cyl(cas[seqpos], cas[other], rad_frac=mask_edge, color=color)

        if ( len(this_cgo) > 0):

            name = "esto_res%i"%seqpos
            cmd.load_cgo(this_cgo, name)
            cmd.disable(name)


    # disables all estograms and then enables the ones you've selected
    def enable_selected():
        selected = list(set([int(x.resi) for x in cmd.get_model("sele").atom]))

        for name in cmd.get_names("objects"):
            if (name.startswith("esto_res")):
                cmd.disable(name)

        for seqpos in selected:
            name = "esto_res%i"%seqpos
            cmd.enable(name)

        cmd.delete("sele")


    cmd.set_key( 'CTRL-C' , enable_selected )

    # restore the camera
    cmd.set_view(save_view)
示例#42
0
文件: B06.py 项目: Almad/pymol
      
from glob import glob

import threading
import time

from pymol import cmd
import sys, os, os.path
import pymol


ent_dir = "pdb"

pymol.run = 1

cmd.set_key('F1',lambda p=pymol:(setattr(p,'run',0)))
cmd.set_key('F2',lambda p=pymol:(setattr(p,'run',1)))

def load():
   r = 0
   rep = [ "simple", "technical", "ligands", "ligand_sites","ligand_sites_trans","ligand_sites_mesh","pretty", "publication" ]
   list = glob("pdb/*/*")
#   while list[0]!="pdb/f8/pdb1f8u":
#      list.pop(0)
   for file in list:
      print file
      cmd.delete('pdb')
      cmd.load(file,'pdb')
      cmd.orient('pdb')
      cur_rep = rep.pop(0)
      rep = rep + [cur_rep]
示例#43
0
    button_list.remove(button_list[0])
    cmd.util.cbag ('all')
    curSel = col2

  else:
    cmd.util.cbag ('all')
    curSel = col2

# colouring selection with specified colour scheme
  cmd.set_color('siff', curSel )
  #cmd.color('siff', InteractionButton[InteractionName.index(butt)]+'_' + t_ + '_'+butt )
  cmd.color('siff', butt )
  butt=[]

cmd.extend('read_siftp', read_siftp)
cmd.set_key( 'F1' , add_color, (any_i_exists, 'any_i_exists' ) )
cmd.set_key( 'F2' , add_color, (backb_exists, 'backb_exists' ) )
cmd.set_key( 'F3' , add_color, (sidec_exists, 'sidec_exists' ) )
cmd.set_key( 'F4' , add_color, (polar_exists, 'polar_exists' ) )
cmd.set_key( 'F5' , add_color, (hphob_exists, 'hphob_exists' ) )
cmd.set_key( 'F6' , add_color, (hbacc_exists, 'hbacc_exists' ) )
cmd.set_key( 'F7' , add_color, (hbdon_exists, 'hbdon_exists' ) )
cmd.set_key( 'F8' , add_color, (aroma_exists, 'aroma_exists' ) )
cmd.set_key( 'F9' , add_color, (charg_exists, 'charg_exists' ) )
cmd.set_key( 'F10' , add_color, (charg_exists, 'env_polar_exists' ) )
cmd.set_key( 'F11' , add_color, (charg_exists, 'env_hydrophobic_exists' ) )
cmd.set_key( 'F12' , add_color, (charg_exists, 'env_aromatic_exists' ) )
cmd.set_key( 'left' , add_color, (charg_exists, 'env_charged_exists' ) )

cmd.set_key( 'F1' , add_color, (any_i_strong, 'any_i_strong' ) )
cmd.set_key( 'F2' , add_color, (backb_strong, 'backb_strong' ) )