예제 #1
0
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()
예제 #2
0
def carve(selection='(all)', cut_range="5", view_key=None):
    cut_range = cut_range.split(":")
    try:
        cut_range = [int(n) for n in cut_range]
    except ValueError as e:
        msg = f"Malformed range {cut_range}"
        e.message = msg
        raise e

    # First align to principal axes
    princ_align(selection)
    cachedir = Path.home() / "mjtadema_pymol_cache"
    if len(cut_range) == 1:
        # symmetrically cut with thickness t
        t = cut_range[0]
        cut_select = f"{selection} and (y > {-t} and y < {t})"
        cmd.orient(cut_select)
        cmd.clip('slab', t * 2, cut_select)
        if view_key is not None:
            cmd.view(view_key, 'store')
    elif len(cut_range) == 2:
        # cut from start to end
        raise NotImplementedError("Didn't get to asymmetric cuts yet")
        pass
    else:
        # panic
        raise ValueError("range can be at most 2 integers")
예제 #3
0
파일: pymol.py 프로젝트: navanchauhan/plip
    def set_initial_representations(self):
        """General settings for PyMOL"""
        self.standard_settings()
        cmd.set('dash_gap', 0)  # Show not dashes, but lines for the pliprofiler
        cmd.set('ray_shadow', 0)  # Turn on ray shadows for clearer ray-traced images
        cmd.set('cartoon_color', 'mylightblue')

        # Set clipping planes for full view
        cmd.clip('far', -1000)
        cmd.clip('near', 1000)
예제 #4
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)
예제 #5
0
	def focus(self):
		self.manager.m = self
		if self.manager.prevm: cmd.hide('sticks',self.manager.prevm.rdes.sel())
		if self.manager.prevm: cmd.color('green',self.manager.prevm.rdes.sel()+" and elem C")
		fr = self.rnat.obj+" and name n+ca+c and resi %i-%i"%(self.rnat.resi-10,self.rnat.resi+10)		
		to = self.rdes.obj+" and name n+ca+c and resi %i-%i"%(self.rdes.resi-10,self.rdes.resi+10)
		cmd.align(fr,to)
		cmd.show('sticks',self.rdes.sel())
		cmd.color('white',self.rdes.sel()+" and elem C")
		cmd.center(self.rdes.sel())
		v = list(cmd.get_view())
		v[11] = -80.0
		cmd.set_view(tuple(v))
		cmd.clip('slab',50,self.rdes.sel())
예제 #6
0
def load_range(begin, end):
    begin = int(begin)
    begin = begin - 1
    end = int(end)
    cmd.reinitialize()
    cmd.bg_color('grey50')
    getoutput('ls | grep \".pdb\" > pdb_list')
    pdb_list = open('pdb_list', 'r')
    pdb_list = fcn('pdb_list')
    getoutput('ls | grep \".pdb\" > pdb_list')
    pdb_list = open('pdb_list', 'r')
    pdb_list = fcn('pdb_list')
    for i in range(begin, end):
        cmd.load(pdb_list[i])
        cmd.disable(pdb_list[i][:15])
    preset.publication('all and not hetatm')
    cmd.show('spheres', 'hetatm')
    cmd.clip("atoms", 5, "all")
    cmd.set("depth_cue", 0)
예제 #7
0
 def testClip(self):
     for a in "xyz":
         cmd.turn(a, random.random() * 10 - 5)
         cmd.move(a, random.random() * 10 - 5)
     v = cmd.get_view()
     cmd.clip("near", -5)
     self.assertAlmostEqual(v[15] + 5, cmd.get_view()[15], delta=1e-3)
     cmd.clip("far", 10)
     self.assertAlmostEqual(v[16] - 10, cmd.get_view()[16], delta=1e-3)
     cmd.clip("move", -15)
     a = cmd.get_view()
     self.assertAlmostEqual(v[15], a[15] - 20, delta=1e-3)
     self.assertAlmostEqual(v[16], a[16] - 5, delta=1e-3)
     cmd.clip("slab", 20)
     v = cmd.get_view()
     self.assertAlmostEqual(v[16] - v[15], 20.0, delta=1e-3)
     cmd.pseudoatom()
     cmd.clip("atoms", 5, "all")
     v = cmd.get_view()
     self.assertAlmostEqual(v[16] - v[15], 10.0, delta=1e-3)
예제 #8
0
 def testClip(self):
     for a in "xyz":
         cmd.turn(a, random.random() * 10 - 5)
         cmd.move(a, random.random() * 10 - 5)
     v = cmd.get_view()
     cmd.clip("near", -5)
     self.assertAlmostEqual(v[15] + 5, cmd.get_view()[15], delta=1e-3)
     cmd.clip("far", 10)
     self.assertAlmostEqual(v[16] - 10, cmd.get_view()[16], delta=1e-3)
     cmd.clip("move", -15)
     a = cmd.get_view()
     self.assertAlmostEqual(v[15], a[15] - 20, delta=1e-3)
     self.assertAlmostEqual(v[16], a[16] - 5, delta=1e-3)
     cmd.clip("slab", 20)
     v = cmd.get_view()
     self.assertAlmostEqual(v[16] - v[15], 20.0, delta=1e-3)
     cmd.pseudoatom()
     cmd.clip("atoms", 5, "all")
     v = cmd.get_view()
     self.assertAlmostEqual(v[16] - v[15], 10.0, delta=1e-3)
예제 #9
0
def prepare_pymol():
    cmd.clip("near", 100000)
    cmd.clip("slab", 100000)
    cmd.clip("far", -100000)
    cmd.show("spheres")
    cmd.unpick()
    util.cbc()
예제 #10
0
    def reinitPymol(self, pdb):
        if len(self.pdb) == 4 and self.pdb == re.match('[a-zA-Z0-9]*',
                                                       self.pdb).group(0):
            cmd.delete(self.pdb)
        if len(pdb) == 4 and pdb == re.match('[a-zA-Z0-9]*', pdb).group(0):
            self.pdb = pdb
            cmd.fetch(self.pdb, async=0)

        if self.editMolecule:
            cmd.hide('everything', 'all')
            cmd.show('cartoon', 'all')

        # color each chain differently
        if self.editMolecule:
            util.cbc()

        # set origin at camera
        if self.naturalRotation:
            self.setOriginAtCamera()

        # move slab away to give a comfortable viewing area
        cmd.clip('move', 10)
예제 #11
0
    def initPymol(self):

        # set stereo mode
        cmd.set('stereo_mode', 3)
        cmd.stereo()

        # get rid of gui
        cmd.set('internal_gui', 0)

        # set resolution to HD for rift
        cmd.viewport(1920, 1080)

        # full screen?
        if self.fullscreen:
            cmd.full_screen('on')

        # load pdb
        if len(self.pdb) == 4 and self.pdb == re.match('[a-zA-Z0-9]*',
                                                       self.pdb).group(0):
            cmd.fetch(self.pdb, async=0)

        if self.editMolecule == True:
            cmd.hide('everything', 'all')
            cmd.show('cartoon', 'all')

        # color each chain differently
        if self.editMolecule:
            util.cbc()

        # set origin at camera
        if self.naturalRotation:
            self.setOriginAtCamera()

        # move slab away to give a comfortable viewing area
        cmd.clip('move', 10)

        # jiggle the camera to deal with blank screen error
        cmd.move('z', .0001)
예제 #12
0
def prepare_pymol():
    cmd.set("ray_trace_color", "black")
    cmd.set("ray_trace_gain", 0)
    cmd.set("ray_trace_mode", 3)
    cmd.set("depth_cue", 0)
    cmd.clip("near", 100000)
    cmd.clip("slab", 100000)
    cmd.clip("far", -100000)
    cmd.hide("all")
    util.cbc()
    cmd.show('surface')
    cmd.bg_color("black")
    cmd.zoom("all", buffer=2.0) # buffer might help clipping problem
    cmd.center("all")
    cmd.deselect()
예제 #13
0
def noclip():
	print "noclip!"
	cmd.clip("near",100)
	cmd.clip("far",-100)
예제 #14
0
def read_moestr(contents,
                object,
                state=0,
                finish=1,
                discrete=1,
                quiet=1,
                zoom=-1,
                _self=cmd):
    moestr = contents
    name = object

    import sys
    if sys.version_info[0] > 2 and isinstance(moestr, bytes):
        moestr = moestr.decode()

    cmd = _self
    mr = MOEReader()
    mr.appendFromStr(moestr)
    split_chains = cmd.get_setting_int("moe_separate_chains")
    cmd.group(name)
    if hasattr(mr, 'system'):
        have_valences = 0
        chain_count = 0
        cmd.set_color("_aseg0", [1.0, 1.0, 1.0])
        aseg_color = cmd.get_color_index("_aseg0")
        aseg_flag = 0
        aseg_rep = {}
        model = Indexed()
        molecule = mr.system['molecule']
        if 'atoms' in molecule:
            n_atom = molecule['atoms']
            model.atom = [Atom() for x in range(n_atom)]
        residues = {}
        chains = {}
        for columns, data in molecule['attr']:
            for row in data:
                cur_atom = None
                for key, value in zip(columns, row):
                    key = key[0]
                    if key == 'ID':
                        ID = value
                    else:
                        aProp = _atom_prop_map.get(key, None)
                        if aProp != None:
                            setattr(model.atom[ID - 1], aProp, value)
                        else:
                            xyz = _atom_coord_map.get(key, None)
                            if xyz != None:
                                coord = list(model.atom[ID - 1].coord)
                                coord[xyz] = value
                                model.atom[ID - 1].coord = coord
                            elif key in _atom_vis_map:
                                atom = model.atom[ID - 1]
                                if hasattr(atom, 'visible'):
                                    visible = atom.visible
                                else:
                                    visible = _default_visible
                                if key == 'aBondLook':
                                    if value == 'cylinder':
                                        atom.visible = 0x00000001 | visible
                                    elif value == 'line':
                                        atom.visible = 0x00000080 | visible
                                    elif value == 'none':
                                        atom.visible = -129 & Visible  # 0xFFFFFF7F
                                elif key == 'aNucleusLook':
                                    if value == 'sphere':
                                        atom.visible = 0x00000002 | visible
                                    elif value == 'small-sphere':  # need to set sphere_scale=0.2 for these atoms
                                        atom.visible = 0x00000002 | visible
                                        atom.sphere_scale = 0.2
                                    elif value == 'point':  # nonbonded
                                        atom.visible = 0x00000800 | visible
                                    elif value == 'none':
                                        atom.visible = -2067 & visible  # 0xFFFFF7ED
                                elif key == 'aHidden':
                                    atom.visible = 0
                                    atom.hidden = 1
                                if hasattr(
                                        atom, 'hidden'
                                ):  # be sure that hidden atoms aren't shown
                                    atom.visible = 0
                            elif key in _atom_color_map:
                                if key == 'aRGB':
                                    model.atom[ID - 1].trgb = value
                                elif key == 'aColorBy':
                                    model.atom[ID - 1].aColorBy = value
                            elif key in _atom_label_map:
                                atom = model.atom[ID - 1]
                                if hasattr(atom, 'label_dict'):
                                    atom.label_dict[key] = None
                                else:
                                    atom.label_dict = {key: None}
                            elif key in _residue_prop_map:
                                resi_dict = residues.get(ID, {})
                                resi_dict[key] = value
                                residues[ID] = resi_dict
                            elif key in _chain_prop_map:
                                chain_dict = chains.get(ID, {})
                                if ID not in chains:
                                    chain_count = chain_count + 1
                                    chain_dict['count'] = chain_count
                                chain_dict[key] = value
                                chains[ID] = chain_dict
        chn_keys = list(chains.keys())
        chn_keys.sort()
        res_keys = list(residues.keys())
        res_keys.sort()
        # map chain properties onto residues
        chn_resi = 0
        ch_colors = copy.deepcopy(_ch_colors)
        unique_chain_names = {}
        for chn_idx in chn_keys:
            chain_dict = chains[chn_idx]
            cName = make_valid_name(chain_dict.get('cName', ''))
            segi = cName[0:4]
            chain = cName[-1:]
            if not len(cName):
                if 'count' in chain_dict:
                    cName = "chain_" + str(chain_dict['count'])
                else:
                    cName = str(chn_idx)
            if cName not in unique_chain_names:
                unique_chain_names[cName] = cName
            else:
                cnt = 2
                while (cName + "_" + str(cnt)) in unique_chain_names:
                    cnt = cnt + 1
                newCName = cName + "_" + str(cnt)
                unique_chain_names[newCName] = cName
                cName = newCName
            chain_dict['chain_color'] = ch_colors[0]
            ch_colors = ch_colors[1:] + [ch_colors[0]]
            cResCount = chain_dict.get('cResidueCount', 0)
            for res_idx in range(chn_resi, chn_resi + cResCount):
                resi_dict = residues[res_keys[res_idx]]
                resi_dict['chain'] = chain
                resi_dict['segi'] = segi
                resi_dict['cName'] = cName
                resi_dict['chain_dict'] = chain_dict
            chn_resi = chn_resi + cResCount
        # map residue properties onto atoms
        res_atom = 0
        for res_idx in res_keys:
            resi_dict = residues[res_idx]
            rRibbonMode = resi_dict.get('rRibbonMode', 'none')
            rAtomCount = resi_dict['rAtomCount']
            rType = resi_dict.get('rType', '')
            if rAtomCount > 0:
                for at_idx in range(res_atom, res_atom + rAtomCount):
                    atom = model.atom[at_idx]
                    setattr(
                        atom, 'resi',
                        string.strip(
                            str(resi_dict.get('rUID', '')) +
                            resi_dict.get('rINS', '')))
                    setattr(atom, 'resn', resi_dict.get('rName', ''))
                    setattr(atom, 'chain', resi_dict.get('chain', ''))
                    setattr(atom, 'segi', resi_dict.get('segi', ''))
                    setattr(atom, 'custom', resi_dict.get('cName', ''))
                    # add labels
                    if hasattr(atom, 'label_dict'):
                        label = ''
                        label_dict = atom.label_dict
                        if 'aLabelElement' in label_dict:
                            label = atom.symbol
                        if 'aLabelRes' in label_dict:
                            if len(label):
                                label = label + ","
                            label = label + atom.resn + "_" + atom.resi
                        if 'aLabelName' in label_dict:
                            if len(label):
                                label = label + "."
                            label = label + atom.name
                        atom.label = label
                    if rType not in ['none', 'heme']:
                        atom.hetatm = 0  # all normal atoms
                    else:
                        atom.flags = 0x02000000  # hetatom or ligand -- ignore when surfacing

                    if rRibbonMode != 'none':
                        if hasattr(atom, 'visible'):
                            visible = atom.visible
                        else:
                            visible = _default_visible

                        rRibbonColorBy = resi_dict['rRibbonColorBy']
                        repeat = 1
                        while repeat:
                            repeat = 0
                            if rRibbonColorBy in ['rgb', 'r:rgb'
                                                  ]:  # handled automatically
                                pass
                            elif rRibbonColorBy == 'chain':
                                chain_dict = resi_dict['chain_dict']
                                cColorBy = chain_dict['cColorBy']
                                if cColorBy == 'rgb':
                                    cColorBy = 'c:rgb'
                                rRibbonColorBy = cColorBy
                                repeat = 1

                        rRibbon_color = 0
                        rRibbon_trgb = 0xFFFFFF  # default -- white

                        # now color ribbon
                        if rRibbonColorBy == 'r:rgb':
                            rRibbon_trgb = resi_dict.get('rRGB', 0xFFFFFF)
                        elif rRibbonColorBy == 'rgb':
                            rRibbon_trgb = resi_dict.get(
                                'rRibbonRGB', 0xFFFFFF)
                        elif rRibbonColorBy == 'c:rgb':
                            chain_dict = resi_dict['chain_dict']
                            rRibbon_trgb = chain_dict.get('cRGB', 0xFFFFFF)
                        elif rRibbonColorBy == 'r:aseg':
                            rRibbon_trgb = None
                            rRibbon_color = aseg_color
                            aseg_flag = 1
                        elif rRibbonColorBy == 'tempfactor':
                            pass  # TO DO
                        elif rRibbonColorBy == 'c:number':  # per chain colors
                            rRibbon_trgb = chain_dict['chain_color']
                        if rRibbonMode in ['line', 'trace']:
                            atom.visible = 0x00000040 | visible  # PyMOL ribbon
                            if rRibbon_trgb != None:
                                atom.ribbon_trgb = rRibbon_trgb
                            else:
                                atom.ribbon_color = rRibbon_color
                            aseg_rep['ribbon'] = 1
                        else:
                            atom.visible = 0x00000020 | visible  # PyMOL cartoon
                            if rRibbon_trgb != None:
                                atom.cartoon_trgb = rRibbon_trgb
                            else:
                                atom.cartoon_color = rRibbon_color
                            aseg_rep['cartoon'] = 1

                    if hasattr(atom, 'label'):
                        if hasattr(atom, 'visible'):
                            visible = atom.visible
                        else:
                            visible = _default_visible
                        atom.visible = 0x00000028 | visible  # labels
                    if not hasattr(atom, 'aColorBy'):
                        atom.aColorBy = 'element'
                    if hasattr(atom, 'aColorBy'):
                        aColorBy = atom.aColorBy
                        repeat = 1
                        while repeat:
                            repeat = 0
                            if aColorBy == 'ribbon':
                                aColorBy = resi_dict.get('rRibbonColorBy')
                                if aColorBy == 'rgb':
                                    aColorBy = 'rib:rgb'
                                else:
                                    repeat = 1
                                # TO DO still need to handle "cartoon_color", "ribbon_color"
                            elif aColorBy == 'element':
                                if hasattr(atom, 'trgb'):
                                    del atom.trgb
                            elif aColorBy in ['rgb', 'a:rgb'
                                              ]:  # handled automatically
                                pass
                            elif aColorBy == 'residue':
                                rColorBy = resi_dict.get('rColorBy')
                                if rColorBy == 'rgb':
                                    rColorBy = 'r:rgb'
                                aColorBy = rColorBy
                                repeat = 1
                            elif aColorBy == 'chain':
                                chain_dict = resi_dict['chain_dict']
                                cColorBy = chain_dict['cColorBy']
                                if cColorBy == 'rgb':
                                    cColorBy = 'c:rgb'
                                aColorBy = cColorBy
                                repeat = 1

                        # now color atom...
                        if aColorBy == 'r:rgb':
                            atom.trgb = resi_dict.get('rRGB', 0xFFFFFF)
                        elif aColorBy == 'rib:rgb':
                            atom.trgb = resi_dict.get('rRibbonRGB', 0xFFFFFF)
                        elif aColorBy == 'c:rgb':
                            chain_dict = resi_dict['chain_dict']
                            atom.trgb = chain_dict.get('cRGB', 0xFFFFFF)
                        elif aColorBy == 'r:aseg':
                            pass  # TO DO
                        elif aColorBy == 'tempfactor':
                            pass  # TO DO
                        elif aColorBy == 'c:number':  # per chain colors
                            atom.trgb = chain_dict['chain_color']

                res_atom = res_atom + rAtomCount
        bond_list = molecule.get('bond', [])
        for bond in bond_list:
            new_bond = Bond()
            new_bond.index = [bond[0] - 1, bond[1] - 1]
            if len(bond) > 2:
                new_bond.order = bond[2]
                if bond[2] == 2:  # work around .MOE bug with triple bonds
                    if model.atom[new_bond.index[0]].hybridization == 'sp':
                        if model.atom[new_bond.index[1]].hybridization == 'sp':
                            new_bond.order = 3
                have_valences = 1
            model.bond.append(new_bond)
        if 'ViewOrientationY' in mr.system:
            vy = mr.system['ViewOrientationY']
            vz = mr.system['ViewOrientationZ']
            pos = mr.system['ViewLookAt']
            scale = mr.system['ViewScale']
            vx = cpv.cross_product(vy, vz)
            m = [cpv.normalize(vx), cpv.normalize(vy), cpv.normalize(vz)]
            m = cpv.transpose(m)
            asp_rat = 0.8  # MOE default (versus 0.75 for PyMOL)
            cmd.set("field_of_view", 25.0)
            fov = float(cmd.get("field_of_view"))
            window_height = scale * asp_rat
            dist = (0.5 * window_height) / math.atan(3.1415 *
                                                     (0.5 * fov) / 180.0)
            new_view = tuple(m[0] + m[1] + m[2] + [0.0, 0.0, -dist] + pos +
                             [dist * 0.5, dist * 1.5, 0.0])
            cmd.set_view(new_view)
            zoom = 0
        cmd.set("auto_color", 0)
        cmd.set_color("carbon", [0.5, 0.5, 0.5])  # default MOE grey

        obj_name = name + ".system"
        if split_chains < 0:  # by default, don't split chains if over 50 objects would be created
            if len(unique_chain_names) > 50:
                split_chains = 0
        if not split_chains:
            cmd.load_model(model,
                           obj_name,
                           state=state,
                           finish=finish,
                           discrete=discrete,
                           quiet=quiet,
                           zoom=zoom)
            obj_name_list = [obj_name]
        else:
            cmd.load_model(model,
                           obj_name,
                           state=state,
                           finish=finish,
                           discrete=discrete,
                           quiet=1,
                           zoom=zoom)
            obj_name_list = []
            system_name = obj_name
            for chain in unique_chain_names.keys():
                obj_name = name + "." + chain
                obj_name_list.append(obj_name)
                cmd.select("_moe_ext_tmp",
                           "custom %s" % chain,
                           domain=system_name)
                cmd.extract(obj_name, "_moe_ext_tmp", quiet=quiet, zoom=0)
                # cmd.extract(obj_name,system_name+" and text_type %s"%chain,quiet=quiet)
                cmd.delete("_moe_ext_tmp")
            if not cmd.count_atoms(system_name):
                cmd.delete(system_name)
            else:
                obj_name_list.append(system_name)
            cmd.order(name + ".*", sort=1)
        for obj_name in obj_name_list:
            cmd.set("stick_radius", 0.1, obj_name)
            cmd.set("line_width", 2.0, obj_name)
            cmd.set("label_color", "white", obj_name)
            cmd.set("nonbonded_size", 0.05,
                    obj_name)  # temporary workaround...
            if have_valences:  # if this MOE file has valences, then show em!
                cmd.set("valence", 1, obj_name)
                cmd.set("stick_valence_scale", 1.25, obj_name)
            if aseg_flag:
                cmd.dss(obj_name)
                if 'cartoon' in aseg_rep:
                    cmd.set("cartoon_color", "red",
                            obj_name + " and cartoon_color _aseg0 and ss h")
                    cmd.set("cartoon_color", "yellow",
                            obj_name + " and cartoon_color _aseg0 and ss s")
                    cmd.set(
                        "cartoon_color", "cyan",
                        obj_name + " and cartoon_color _aseg0 and not ss h+s")
                if 'ribbon' in aseg_rep:
                    cmd.set("ribbon_color", "red",
                            obj_name + " and ribbon_color _aseg0 and ss h"
                            )  # need selection op ribbon_color
                    cmd.set("ribbon_color", "yellow",
                            obj_name + " and ribbon_color _aseg0 and ss s")
                    cmd.set(
                        "ribbon_color", "cyan",
                        obj_name + " and ribbon_color _aseg0 and not ss h+s")
        if 'ViewZFront' in mr.system:
            moe_front = mr.system['ViewZFront']
            moe_width = mr.system['ViewZWidth']
            extent = cmd.get_extent(
                name)  # will this work with groups? TO DO: check!
            dx = (extent[0][0] - extent[1][0])
            dy = (extent[0][1] - extent[1][1])
            dz = (extent[0][2] - extent[1][2])
            half_width = 0.5 * math.sqrt(dx * dx + dy * dy + dz * dz)
            cmd.clip("atoms", 0.0, name)
            cur_view = cmd.get_view()
            center = (cur_view[-3] +
                      cur_view[-2]) * 0.5  # center of clipping slab
            front = center - half_width
            back = center + half_width
            width = half_width * 2
            new_view = tuple(
                list(cur_view[0:15]) + [
                    front + width * moe_front, front + width *
                    (moe_front + moe_width), 0.0
                ])
            cmd.set_view(new_view)
        if 'graphics' in mr.system:
            cgo_cnt = 1
            lab_cnt = 1
            unique_cgo_names = {}
            for graphics in mr.system['graphics']:
                cgo = []
                for gvertex in graphics.get('gvertex', []):
                    vrt = gvertex[0]
                    seg_list = gvertex[1]['seg']
                    idx = gvertex[1]['idx']
                    len_idx = len(idx)
                    if not cmd.is_list(seg_list):
                        seg_list = [seg_list] * (len_idx / seg_list)
                    last_seg = None
                    ix_start = 0
                    for seg in seg_list:
                        if seg != last_seg:
                            if last_seg != None:
                                cgo.append(END)
                            if seg == 3:
                                cgo.extend([BEGIN, TRIANGLES])
                            elif seg == 2:
                                cgo.extend([BEGIN, LINES])
                            elif seg == 1:
                                cgo.extend([BEGIN, POINTS])
                        ix_stop = seg + ix_start
                        if seg == 3:
                            for s in idx[ix_start:ix_stop]:
                                v = vrt[s - 1]
                                cgo.extend([
                                    COLOR, (0xFF & (v[0] >> 16)) / 255.0,
                                    (0xFF & (v[0] >> 8)) / 255.0,
                                    (0xFF & (v[0])) / 255.0
                                ])
                                if len(v) > 4:
                                    cgo.extend([NORMAL, v[4], v[5], v[6]])
                                cgo.extend([VERTEX, v[1], v[2], v[3]])
                        elif seg == 2:
                            for s in idx[ix_start:ix_stop]:
                                v = vrt[s - 1]
                                cgo.extend([
                                    COLOR, (0xFF & (v[0] >> 16)) / 255.0,
                                    (0xFF & (v[0] >> 8)) / 255.0,
                                    (0xFF & (v[0])) / 255.0
                                ])
                                if len(v) > 4:
                                    cgo.extend([NORMAL, v[4], v[5], v[6]])
                                cgo.extend([VERTEX, v[1], v[2], v[3]])
                        elif seg == 1:
                            for s in idx[ix_start:ix_stop]:
                                v = vrt[s - 1]
                                cgo.extend([
                                    COLOR, (0xFF & (v[0] >> 16)) / 255.0,
                                    (0xFF & (v[0] >> 8)) / 255.0,
                                    (0xFF & (v[0])) / 255.0
                                ])
                                if len(v) > 4:
                                    cgo.extend([NORMAL, v[4], v[5], v[6]])
                                cgo.extend([VERTEX, v[1], v[2], v[3]])
                        ix_start = ix_stop
                        last_seg = seg
                    if last_seg != None:
                        cgo.append(END)
                for gtext in graphics.get('gtext', []):
                    lab_name = name + ".label_%02d" % lab_cnt
                    exists = 0
                    for entry in gtext:
                        exists = 1
                        cmd.pseudoatom(lab_name,
                                       pos=[
                                           float(entry[1]),
                                           float(entry[2]),
                                           float(entry[3])
                                       ],
                                       color="0x%06x" % entry[0],
                                       label=entry[4])
                    if exists:
                        cmd.set('label_color', -1, lab_name)
                        lab_cnt = lab_cnt + 1
                    # TO DO -- via CGO's?

                if len(cgo):
                    cgo_name = name + "." + make_valid_name(
                        graphics.get('GTitle', 'graphics'))
                    if cgo_name not in unique_cgo_names:
                        unique_cgo_names[cgo_name] = cgo_name
                    else:
                        cnt = 2
                        while cgo_name + "_" + str(cnt) in unique_cgo_names:
                            cnt = cnt + 1
                        new_name = cgo_name + "_" + str(cnt)
                        unique_cgo_names[new_name] = new_name
                        cgo_name = new_name
                    cmd.load_cgo(cgo,
                                 cgo_name,
                                 state=state,
                                 quiet=quiet,
                                 zoom=0)
                    cgo_cnt = cgo_cnt + 1
                    cmd.set("two_sided_lighting", 1)  # global setting...
                    cmd.set("cgo_line_width", 2, cgo_name)
                    if 'GTransparency' in graphics:
                        g_trans = graphics['GTransparency']
                        if len(g_trans) >= 2:
                            if g_trans[0] != 0:
                                cmd.set('cgo_transparency',
                                        '%1.6f' % (g_trans[0] / 255.0),
                                        cgo_name)
                                cmd.set('transparency_global_sort')
        if 'meter' in mr.system:
            meter_name = name + ".meter"
            exists = 0
            for meter_block in mr.system['meter']:
                if meter_block[0][0:2] == ['type', 'atoms']:
                    for meter in meter_block[1]:
                        (type, atoms) = meter[0:2]
                        arg = tuple([meter_name] + list(
                            map(lambda x, o=name: o + " and id " + str(x - 1),
                                atoms)))
                        getattr(cmd, type)(*arg)
                        exists = 1
            if exists:
                cmd.color("green", meter_name)
#            print mr.system['meter']
    elif hasattr(mr, 'feature'):
        model = Indexed()
        cols = mr.feature[0]
        rows = mr.feature[1]
        col = {}
        cnt = 0
        for a in cols:
            col[a] = cnt
            cnt = cnt + 1
        for row in rows:
            atom = Atom()
            atom.coord = [row[col['x']], row[col['y']], row[col['z']]]
            atom.vdw = row[col['r']]
            atom.custom = row[col['expr']]
            model.atom.append(atom)
        obj_name = name + ".feature"
        cmd.load_model(model,
                       obj_name,
                       state=state,
                       finish=finish,
                       discrete=discrete,
                       quiet=quiet,
                       zoom=zoom)
        rank = 1
        for row in rows:
            cmd.color("0x%06x" % row[col['color']],
                      obj_name + " & id %d" % (rank - 1))
            rank = rank + 1
        cmd.show("mesh", obj_name)
        cmd.set("min_mesh_spacing", 0.55, obj_name)
        cmd.label(obj_name, "' '+custom")
        cmd.set("label_color", "yellow", obj_name)
    else:
        print(dir(mr))
예제 #15
0
        2.0,  # Radius
        1.0,
        (1.0 + math.sin(aa)) / 2.0,
        (1.0 + math.cos(aa)) / 2.0,  # RGB Color 1
        0.3,
        (1.0 + math.cos(aa)) / 2.0,
        0.5,  # RGB Color 2
    ])

    # load this state into the PyMOL object

    cmd.load_cgo(obj, 'cgo03', a + 1)

# this zooms out a bit more than usual

cmd.reset()
cmd.zoom('cgo03', 3.0)

# this moves the rear clipping plane back a bit

cmd.clip('far', -12.0)

# give us a nice view

cmd.turn('z', 30)
cmd.turn('x', -60)

# start the movie

cmd.mplay()
예제 #16
0
def get_dude_image(entry, mol, original = True):
    data_folder = 'Data/'
    father_folder = data_folder + 'PNG_' + str(original) + '/'
    if not os.path.exists(father_folder):
        os.mkdir(father_folder)
    folder = father_folder + entry + '/'
    if not os.path.exists(folder):
        os.mkdir(folder)
    mol_name = mol[:-5]
    folder += mol_name + '/'
    if not os.path.exists(folder):
        os.mkdir(folder)
    docking_folder = entry
    if original:
        docking_folder += '/actives_Dock/poses/'
    else:
        docking_folder += '/decoys_Dock2/poses/'
    file_name = entry + '/rec.pdb'
    xtal = docking_folder + mol

    steps = 3
    step_angle = 360.0 / steps
    pixels = 100
    num_rand = 9

    pymol.finish_launching()
    cmd.delete('all')
    cmd.load(file_name, 'protein')
    cmd.load(xtal, mol_name)
    cmd.select('lig', mol_name)
    obj_name = mol_name
    delete_hetero('lig')
    cmd.remove('hydrogen')
    if cmd.count_atoms('lig') == 0:
        os.rmdir(folder)
        return 0
    cmd.select('rec', 'br. lig around 4 and poly')
    cmd.hide("all")
    cmd.color('white', 'rec')
    cmd.color('green', 'lig')
    cmd.util.cnc("all")
    cmd.show("sticks", 'lig')
    #Show H bonds
    cmd.set('h_bond_cutoff_center', 3.5)
    cmd.distance('hbonds', 'lig', 'rec', mode=2)
    cmd.hide('labels')
    #Show double bonds
    #cmd.set('valence', 1, obj_name)
    cmd.orient('lig')
    cmd.zoom('lig', 3)
    #Slab move -5
    cmd.clip('move', -5)
    cmd.set('ray_opaque_background', 0)                                                                         
    cmd.set('ray_shadows', 0)

    for show in ['sticks']:#['surface', 'sticks']:
        #Set transparency
#        tra = 0
#        if show == 'surface':
#            tra = 0.5
#        cmd.set('transparency', tra)
        cmd.show(show, 'rec')
        refresh()
        for x in range(steps):
            for y in range(steps):
                refresh()
                cmd.png(folder + show + '_' + str(x) + '_' + str(y) + '.png', pixels, pixels)
                refresh()
                cmd.turn('y', step_angle)
                refresh()
            cmd.turn('x', step_angle)
            refresh()
        cmd.hide(show, 'rec')
        refresh()
    return 1
예제 #17
0
cmd.alter("name Hice", "vdw=0.8000")
cmd.alter("name Oice", "vdw=1.6000")
cmd.alter("name Ccod", "vdw=1.7000")
cmd.alter("name Ocod", "vdw=1.6000")

cmd.select("protein", "all  and not hetatm")
cmd.select("surface", "hetatm and not resn doc")
cmd.disable("surface")
cmd.disable("protein")
cmd.show("cartoon")
cmd.set("cartoon_fancy_helices", 1)
cmd.spectrum("count", selection="(protein)&e. c")
#preset.publication("protein")
cmd.show("spheres", "surface")
cmd.clip("atoms", 5, "all")
cmd.select("prot_int", "protein w. 5 of surface")
cmd.disable('prot_int')
cmd.select("surf_int", "surface w. 5 of protein")
cmd.disable('surf_int')
cmd.hide("everything", "surface")
cmd.show("spheres", "surf_int")
cmd.show("sticks", "((byres (prot_int))&(!(n;c,o,h|(n. n&!r. pro))))")
cmd.space('cmyk')
cmd.bg_color('black')
cmd.select("BackBone", "name c+ca+o+n")
cmd.select("SC_Carbon", "elem c and not BackBone")
cmd.color("grey60", "SC_Carbon")
cmd.disable('SC_Carbon')
############## OSTEOCALCIN STUFF ###############
cmd.color("red", "name OE11")
예제 #18
0
 def noclip():
     """Sets clipping to nearly infinity."""
     cmd.clip('near', 99999999)
     cmd.clip('far', -99999999)
예제 #19
0
   
   # counter label
   
   pdb_list = [
      "HETATM%5d  C   UNK     1    %8.3f%8.3f%8.3f  1.00 10.00\n"%(c,2.0,0,2.0),
      ]
   cmd.read_pdbstr(string.join(pdb_list,''),'lab1',c,discrete=1)
   cmd.label("(lab1 and id %d)"%c,"'frame %d %6.3f'"%(c,math.sin(a/10.0)))


cmd.hide("nonbonded","lab1")

# axes labels


pdb_list = [
"HETATM    1  X   UNK     1    %8.3f%8.3f%8.3f  1.00 10.00\n"%(3.2,0,0),
"HETATM    2  Y   UNK     2    %8.3f%8.3f%8.3f  1.00 10.00\n"%(0,3.2,0),
"HETATM    3  Z   UNK     3    %8.3f%8.3f%8.3f  1.00 10.00\n"%(0,0,3.2),]
cmd.read_pdbstr(string.join(pdb_list,''),'lab2')
cmd.hide('(lab2)')
cmd.label('lab2','name')
cmd.color('white','lab2')


cmd.zoom('cgo01')
cmd.clip('far',-5)

cmd.mplay()

예제 #20
0
def get_image(ind, pdb_name, mol, chain, res, original = True):
    data_folder = 'Data/'
    father_folder = data_folder + 'PNG_' + str(original) + '/'
    #if not os.path.exists(father_folder):
    #    os.mkdir(father_folder)
    folder = father_folder + ind + '_' + pdb_name + '/'
    if not os.path.exists(folder):
        os.mkdir(folder)
    ugly_id = 'cand4'
    true_id = 'cand1'
    docking_folder = 'RosettaDock/'
    file_name = docking_folder + ind + '_' + pdb_name + '/rec1.pdb'
    ugly_rec = docking_folder + ind + '_' + pdb_name + '/rec4.pdb'
    ugly_name = docking_folder + ind + '_' + pdb_name + '/' + ugly_id + '.mol2'
    xtal = docking_folder + ind + '_' + pdb_name + '/' + true_id + '.mol2'

    steps = 3
    step_angle = 360.0 / steps
    pixels = 100
    num_rand = 9

    #This is done for negative of random rotation in the pocket
    '''if not original:
        fake_rotation = []
        for _ in range(3):
            fake_rotation.append(random.random() * 360)'''

    pymol.finish_launching()
    cmd.delete('all')
    if original:
        cmd.load(file_name, 'protein')
    else:
        if not os.path.exists(ugly_rec):
            os.rmdir(folder)
            return 0
        cmd.load(ugly_rec, 'protein')
    cmd.load(xtal)
    #cmd.select('lig', 'resn ' + mol + ' and chain ' + chain + ' and resi ' + res)
    cmd.select('lig', true_id)
    obj_name = true_id
    if not original:
        if not os.path.exists(ugly_name):
            os.rmdir(folder)
            return 0
        cmd.load(ugly_name)
        cmd.select('lig', ugly_id)
        obj_name = ugly_id
    delete_hetero('lig')
    cmd.remove('hydrogen')
    if cmd.count_atoms('lig') == 0:
        os.rmdir(folder)
        return 0
    #cmd.select('rec', 'not lig')
    cmd.select('rec', 'br. lig around 4 and poly')
    cmd.hide("all")
    cmd.color('white', 'rec')
    cmd.color('green', 'lig')
    cmd.util.cnc("all")
    cmd.show("sticks", 'lig')
    #Show H bonds
    cmd.set('h_bond_cutoff_center', 3.5)
    cmd.distance('hbonds', 'lig', 'rec', mode=2)
    cmd.hide('labels')
    #Show double bonds
    #cmd.set('valence', 1, obj_name)
    cmd.orient('lig')
    cmd.zoom('lig', 3)
    #Slab move -5
    cmd.clip('move', -5)
    cmd.set('ray_opaque_background', 0)                                                                         
    cmd.set('ray_shadows', 0)

    #This is done for negative of random rotation in the pocket
    '''if not original:
        cmd.rotate('x', fake_rotation[0], 'lig')
        cmd.rotate('y', fake_rotation[1], 'lig')
        cmd.rotate('z', fake_rotation[2], 'lig')'''
    
    #Transperent surface
    '''cmd.set('surface_carve_cutoff', 4.5)
    cmd.set('surface_carve_selection', 'lig')
    cmd.set('surface_carve_normal_cutoff', -0.1)
    cmd.set('surface_color', 'white')
    cmd.set('surface_type', 3)
    cmd.set('transparency', 0.5)'''

    for show in ['sticks']:#['surface', 'sticks']:
        #Set transparency
#        tra = 0
#        if show == 'surface':
#            tra = 0.5
#        cmd.set('transparency', tra)
        cmd.show(show, 'rec')
        refresh()
        for x in range(steps):
            for y in range(steps):
                refresh()
                cmd.png(folder + show + '_' + str(x) + '_' + str(y) + '.png', pixels, pixels)
                refresh()
                cmd.turn('y', step_angle)
                refresh()
            cmd.turn('x', step_angle)
            refresh()
        '''for x in range(num_rand):
            refresh()
            for ax in ['x', 'y', 'z']:
                cmd.turn(ax, random.random() * 360)
            refresh()
            cmd.png(folder + show + '_' + str(x) + '.png', pixels, pixels)
            refresh()'''
        cmd.hide(show, 'rec')
        refresh()
    return 1
예제 #21
0
파일: movie.py 프로젝트: q10/bioe243


c=0
for a in xrange(0,100):
   cluster.MD_step()
   balls = []
   for i in xrange(0,cluster.N):
       balls.extend([COLOR,
                     1.0,
                     1.0,
                     1.0,
                     SPHERE,
                     cluster.particles[i].x,
                     cluster.particles[i].y,
                     cluster.particles[i].z,
                     0.5,])
   obj = axes + balls
   cmd.load_cgo(obj,'cgo01',c)
   c = c + 1

pdb_list = [
"HETATM 1 X UNK 1 %8.3f%8.3f%8.3f 1.00 10.00\n"%(3.2,0,0), "HETATM 2 Y UNK 2 %8.3f%8.3f%8.3f 1.00 10.00\n"%(0,3.2,0), "HETATM 3 Z UNK 3 %8.3f%8.3f%8.3f 1.00 10.00\n"%(0,0,3.2),
           ]
cmd.read_pdbstr(string.join(pdb_list,''),'lab2')
cmd.hide('(lab2)')
cmd.label('lab2','name')
cmd.color('white','lab2')
#cmd.zoom('cgo01')
cmd.clip('far',-5)
예제 #22
0
파일: cgo03.py 프로젝트: Almad/pymol
                 5.0,  15+math.sin(aa)*10, -5.0,      # XYZ 1
                 25.0, 15+math.sin(aa)*10, -5.0,      # XYZ 2
                 2.0,                                     # Radius
                 1.0, (1.0+math.sin(aa))/2.0,(1.0+math.cos(aa))/2.0, # RGB Color 1
                 0.3, (1.0+math.cos(aa))/2.0, 0.5,              # RGB Color 2
                 ] )
                
   # load this state into the PyMOL object

   cmd.load_cgo(obj,'cgo03',a+1)

# this zooms out a bit more than usual

cmd.reset()
cmd.zoom('cgo03',3.0)

# this moves the rear clipping plane back a bit

cmd.clip('far',-12.0)

# give us a nice view

cmd.turn('z',30)
cmd.turn('x',-60)

# start the movie

cmd.mplay()